1/* Generated from krb5.asn1 */
2/* Do not edit */
3
4#define ASN1_LIB
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <time.h>
9#include <string.h>
10#include <errno.h>
11#include <limits.h>
12#include <krb5/krb5-types.h>
13#include "krb5_asn1.h"
14#include "krb5_asn1-priv.h"
15#include <krb5/asn1_err.h>
16#include <krb5/der.h>
17#include <asn1-template.h>
18
19#include <krb5/parse_units.h>
20
21int ASN1CALL
22encode_NAME_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NAME_TYPE *data, size_t *size)
23{
24size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
25size_t l HEIMDAL_UNUSED_ATTRIBUTE;
26int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
27
28{
29int enumint = (int)*data;
30e = der_put_integer(p, len, &enumint, &l);
31if (e) return e;
32p -= l; len -= l; ret += l;
33
34}
35;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
36if (e) return e;
37p -= l; len -= l; ret += l;
38
39*size = ret;
40return 0;
41}
42
43int ASN1CALL
44decode_NAME_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NAME_TYPE *data, size_t *size)
45{
46size_t ret = 0;
47size_t l HEIMDAL_UNUSED_ATTRIBUTE;
48int e HEIMDAL_UNUSED_ATTRIBUTE;
49
50memset(data, 0, sizeof(*data));
51{
52size_t Top_datalen, Top_oldlen;
53Der_type Top_type;
54e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
55if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
56if(e) goto fail;
57p += l; len -= l; ret += l;
58Top_oldlen = len;
59if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
60len = Top_datalen;
61{
62int enumint;
63e = der_get_integer(p, len, &enumint, &l);
64if(e) goto fail;
65p += l; len -= l; ret += l;
66*data = enumint;
67}
68len = Top_oldlen - Top_datalen;
69}
70if(size) *size = ret;
71return 0;
72fail:
73free_NAME_TYPE(data);
74return e;
75}
76
77void ASN1CALL
78free_NAME_TYPE(NAME_TYPE *data)
79{
80}
81
82size_t ASN1CALL
83length_NAME_TYPE(const NAME_TYPE *data)
84{
85size_t ret = 0;
86{
87int enumint = *data;
88ret += der_length_integer(&enumint);
89}
90ret += 1 + der_length_len (ret);
91return ret;
92}
93
94int ASN1CALL
95copy_NAME_TYPE(const NAME_TYPE *from, NAME_TYPE *to)
96{
97memset(to, 0, sizeof(*to));
98*(to) = *(from);
99return 0;
100}
101
102int ASN1CALL
103encode_MESSAGE_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const MESSAGE_TYPE *data, size_t *size)
104{
105size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
106size_t l HEIMDAL_UNUSED_ATTRIBUTE;
107int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
108
109{
110int enumint = (int)*data;
111e = der_put_integer(p, len, &enumint, &l);
112if (e) return e;
113p -= l; len -= l; ret += l;
114
115}
116;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
117if (e) return e;
118p -= l; len -= l; ret += l;
119
120*size = ret;
121return 0;
122}
123
124int ASN1CALL
125decode_MESSAGE_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, MESSAGE_TYPE *data, size_t *size)
126{
127size_t ret = 0;
128size_t l HEIMDAL_UNUSED_ATTRIBUTE;
129int e HEIMDAL_UNUSED_ATTRIBUTE;
130
131memset(data, 0, sizeof(*data));
132{
133size_t Top_datalen, Top_oldlen;
134Der_type Top_type;
135e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
136if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
137if(e) goto fail;
138p += l; len -= l; ret += l;
139Top_oldlen = len;
140if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
141len = Top_datalen;
142{
143int enumint;
144e = der_get_integer(p, len, &enumint, &l);
145if(e) goto fail;
146p += l; len -= l; ret += l;
147*data = enumint;
148}
149len = Top_oldlen - Top_datalen;
150}
151if(size) *size = ret;
152return 0;
153fail:
154free_MESSAGE_TYPE(data);
155return e;
156}
157
158void ASN1CALL
159free_MESSAGE_TYPE(MESSAGE_TYPE *data)
160{
161}
162
163size_t ASN1CALL
164length_MESSAGE_TYPE(const MESSAGE_TYPE *data)
165{
166size_t ret = 0;
167{
168int enumint = *data;
169ret += der_length_integer(&enumint);
170}
171ret += 1 + der_length_len (ret);
172return ret;
173}
174
175int ASN1CALL
176copy_MESSAGE_TYPE(const MESSAGE_TYPE *from, MESSAGE_TYPE *to)
177{
178memset(to, 0, sizeof(*to));
179*(to) = *(from);
180return 0;
181}
182
183int ASN1CALL
184encode_PADATA_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PADATA_TYPE *data, size_t *size)
185{
186size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
187size_t l HEIMDAL_UNUSED_ATTRIBUTE;
188int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
189
190{
191int enumint = (int)*data;
192e = der_put_integer(p, len, &enumint, &l);
193if (e) return e;
194p -= l; len -= l; ret += l;
195
196}
197;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
198if (e) return e;
199p -= l; len -= l; ret += l;
200
201*size = ret;
202return 0;
203}
204
205int ASN1CALL
206decode_PADATA_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PADATA_TYPE *data, size_t *size)
207{
208size_t ret = 0;
209size_t l HEIMDAL_UNUSED_ATTRIBUTE;
210int e HEIMDAL_UNUSED_ATTRIBUTE;
211
212memset(data, 0, sizeof(*data));
213{
214size_t Top_datalen, Top_oldlen;
215Der_type Top_type;
216e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
217if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
218if(e) goto fail;
219p += l; len -= l; ret += l;
220Top_oldlen = len;
221if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
222len = Top_datalen;
223{
224int enumint;
225e = der_get_integer(p, len, &enumint, &l);
226if(e) goto fail;
227p += l; len -= l; ret += l;
228*data = enumint;
229}
230len = Top_oldlen - Top_datalen;
231}
232if(size) *size = ret;
233return 0;
234fail:
235free_PADATA_TYPE(data);
236return e;
237}
238
239void ASN1CALL
240free_PADATA_TYPE(PADATA_TYPE *data)
241{
242}
243
244size_t ASN1CALL
245length_PADATA_TYPE(const PADATA_TYPE *data)
246{
247size_t ret = 0;
248{
249int enumint = *data;
250ret += der_length_integer(&enumint);
251}
252ret += 1 + der_length_len (ret);
253return ret;
254}
255
256int ASN1CALL
257copy_PADATA_TYPE(const PADATA_TYPE *from, PADATA_TYPE *to)
258{
259memset(to, 0, sizeof(*to));
260*(to) = *(from);
261return 0;
262}
263
264int ASN1CALL
265encode_AUTHDATA_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AUTHDATA_TYPE *data, size_t *size)
266{
267size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
268size_t l HEIMDAL_UNUSED_ATTRIBUTE;
269int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
270
271{
272int enumint = (int)*data;
273e = der_put_integer(p, len, &enumint, &l);
274if (e) return e;
275p -= l; len -= l; ret += l;
276
277}
278;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
279if (e) return e;
280p -= l; len -= l; ret += l;
281
282*size = ret;
283return 0;
284}
285
286int ASN1CALL
287decode_AUTHDATA_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AUTHDATA_TYPE *data, size_t *size)
288{
289size_t ret = 0;
290size_t l HEIMDAL_UNUSED_ATTRIBUTE;
291int e HEIMDAL_UNUSED_ATTRIBUTE;
292
293memset(data, 0, sizeof(*data));
294{
295size_t Top_datalen, Top_oldlen;
296Der_type Top_type;
297e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
298if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
299if(e) goto fail;
300p += l; len -= l; ret += l;
301Top_oldlen = len;
302if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
303len = Top_datalen;
304{
305int enumint;
306e = der_get_integer(p, len, &enumint, &l);
307if(e) goto fail;
308p += l; len -= l; ret += l;
309*data = enumint;
310}
311len = Top_oldlen - Top_datalen;
312}
313if(size) *size = ret;
314return 0;
315fail:
316free_AUTHDATA_TYPE(data);
317return e;
318}
319
320void ASN1CALL
321free_AUTHDATA_TYPE(AUTHDATA_TYPE *data)
322{
323}
324
325size_t ASN1CALL
326length_AUTHDATA_TYPE(const AUTHDATA_TYPE *data)
327{
328size_t ret = 0;
329{
330int enumint = *data;
331ret += der_length_integer(&enumint);
332}
333ret += 1 + der_length_len (ret);
334return ret;
335}
336
337int ASN1CALL
338copy_AUTHDATA_TYPE(const AUTHDATA_TYPE *from, AUTHDATA_TYPE *to)
339{
340memset(to, 0, sizeof(*to));
341*(to) = *(from);
342return 0;
343}
344
345int ASN1CALL
346encode_CKSUMTYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CKSUMTYPE *data, size_t *size)
347{
348size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
349size_t l HEIMDAL_UNUSED_ATTRIBUTE;
350int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
351
352{
353int enumint = (int)*data;
354e = der_put_integer(p, len, &enumint, &l);
355if (e) return e;
356p -= l; len -= l; ret += l;
357
358}
359;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
360if (e) return e;
361p -= l; len -= l; ret += l;
362
363*size = ret;
364return 0;
365}
366
367int ASN1CALL
368decode_CKSUMTYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CKSUMTYPE *data, size_t *size)
369{
370size_t ret = 0;
371size_t l HEIMDAL_UNUSED_ATTRIBUTE;
372int e HEIMDAL_UNUSED_ATTRIBUTE;
373
374memset(data, 0, sizeof(*data));
375{
376size_t Top_datalen, Top_oldlen;
377Der_type Top_type;
378e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
379if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
380if(e) goto fail;
381p += l; len -= l; ret += l;
382Top_oldlen = len;
383if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
384len = Top_datalen;
385{
386int enumint;
387e = der_get_integer(p, len, &enumint, &l);
388if(e) goto fail;
389p += l; len -= l; ret += l;
390*data = enumint;
391}
392len = Top_oldlen - Top_datalen;
393}
394if(size) *size = ret;
395return 0;
396fail:
397free_CKSUMTYPE(data);
398return e;
399}
400
401void ASN1CALL
402free_CKSUMTYPE(CKSUMTYPE *data)
403{
404}
405
406size_t ASN1CALL
407length_CKSUMTYPE(const CKSUMTYPE *data)
408{
409size_t ret = 0;
410{
411int enumint = *data;
412ret += der_length_integer(&enumint);
413}
414ret += 1 + der_length_len (ret);
415return ret;
416}
417
418int ASN1CALL
419copy_CKSUMTYPE(const CKSUMTYPE *from, CKSUMTYPE *to)
420{
421memset(to, 0, sizeof(*to));
422*(to) = *(from);
423return 0;
424}
425
426int ASN1CALL
427encode_ENCTYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ENCTYPE *data, size_t *size)
428{
429size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
430size_t l HEIMDAL_UNUSED_ATTRIBUTE;
431int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
432
433{
434int enumint = (int)*data;
435e = der_put_integer(p, len, &enumint, &l);
436if (e) return e;
437p -= l; len -= l; ret += l;
438
439}
440;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
441if (e) return e;
442p -= l; len -= l; ret += l;
443
444*size = ret;
445return 0;
446}
447
448int ASN1CALL
449decode_ENCTYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ENCTYPE *data, size_t *size)
450{
451size_t ret = 0;
452size_t l HEIMDAL_UNUSED_ATTRIBUTE;
453int e HEIMDAL_UNUSED_ATTRIBUTE;
454
455memset(data, 0, sizeof(*data));
456{
457size_t Top_datalen, Top_oldlen;
458Der_type Top_type;
459e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
460if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
461if(e) goto fail;
462p += l; len -= l; ret += l;
463Top_oldlen = len;
464if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
465len = Top_datalen;
466{
467int enumint;
468e = der_get_integer(p, len, &enumint, &l);
469if(e) goto fail;
470p += l; len -= l; ret += l;
471*data = enumint;
472}
473len = Top_oldlen - Top_datalen;
474}
475if(size) *size = ret;
476return 0;
477fail:
478free_ENCTYPE(data);
479return e;
480}
481
482void ASN1CALL
483free_ENCTYPE(ENCTYPE *data)
484{
485}
486
487size_t ASN1CALL
488length_ENCTYPE(const ENCTYPE *data)
489{
490size_t ret = 0;
491{
492int enumint = *data;
493ret += der_length_integer(&enumint);
494}
495ret += 1 + der_length_len (ret);
496return ret;
497}
498
499int ASN1CALL
500copy_ENCTYPE(const ENCTYPE *from, ENCTYPE *to)
501{
502memset(to, 0, sizeof(*to));
503*(to) = *(from);
504return 0;
505}
506
507int ASN1CALL
508encode_krb5uint32(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const krb5uint32 *data, size_t *size)
509{
510size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
511size_t l HEIMDAL_UNUSED_ATTRIBUTE;
512int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
513
514e = der_put_unsigned(p, len, data, &l);
515if (e) return e;
516p -= l; len -= l; ret += l;
517
518e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
519if (e) return e;
520p -= l; len -= l; ret += l;
521
522*size = ret;
523return 0;
524}
525
526int ASN1CALL
527decode_krb5uint32(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, krb5uint32 *data, size_t *size)
528{
529size_t ret = 0;
530size_t l HEIMDAL_UNUSED_ATTRIBUTE;
531int e HEIMDAL_UNUSED_ATTRIBUTE;
532
533memset(data, 0, sizeof(*data));
534{
535size_t Top_datalen, Top_oldlen;
536Der_type Top_type;
537e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
538if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
539if(e) goto fail;
540p += l; len -= l; ret += l;
541Top_oldlen = len;
542if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
543len = Top_datalen;
544e = der_get_unsigned(p, len, data, &l);
545if(e) goto fail;
546p += l; len -= l; ret += l;
547len = Top_oldlen - Top_datalen;
548}
549if(size) *size = ret;
550return 0;
551fail:
552free_krb5uint32(data);
553return e;
554}
555
556void ASN1CALL
557free_krb5uint32(krb5uint32 *data)
558{
559}
560
561size_t ASN1CALL
562length_krb5uint32(const krb5uint32 *data)
563{
564size_t ret = 0;
565ret += der_length_unsigned(data);
566ret += 1 + der_length_len (ret);
567return ret;
568}
569
570int ASN1CALL
571copy_krb5uint32(const krb5uint32 *from, krb5uint32 *to)
572{
573memset(to, 0, sizeof(*to));
574*(to) = *(from);
575return 0;
576}
577
578int ASN1CALL
579encode_krb5int32(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const krb5int32 *data, size_t *size)
580{
581size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
582size_t l HEIMDAL_UNUSED_ATTRIBUTE;
583int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
584
585e = der_put_integer(p, len, data, &l);
586if (e) return e;
587p -= l; len -= l; ret += l;
588
589e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
590if (e) return e;
591p -= l; len -= l; ret += l;
592
593*size = ret;
594return 0;
595}
596
597int ASN1CALL
598decode_krb5int32(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, krb5int32 *data, size_t *size)
599{
600size_t ret = 0;
601size_t l HEIMDAL_UNUSED_ATTRIBUTE;
602int e HEIMDAL_UNUSED_ATTRIBUTE;
603
604memset(data, 0, sizeof(*data));
605{
606size_t Top_datalen, Top_oldlen;
607Der_type Top_type;
608e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
609if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
610if(e) goto fail;
611p += l; len -= l; ret += l;
612Top_oldlen = len;
613if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
614len = Top_datalen;
615e = der_get_integer(p, len, data, &l);
616if(e) goto fail;
617p += l; len -= l; ret += l;
618len = Top_oldlen - Top_datalen;
619}
620if(size) *size = ret;
621return 0;
622fail:
623free_krb5int32(data);
624return e;
625}
626
627void ASN1CALL
628free_krb5int32(krb5int32 *data)
629{
630}
631
632size_t ASN1CALL
633length_krb5int32(const krb5int32 *data)
634{
635size_t ret = 0;
636ret += der_length_integer(data);
637ret += 1 + der_length_len (ret);
638return ret;
639}
640
641int ASN1CALL
642copy_krb5int32(const krb5int32 *from, krb5int32 *to)
643{
644memset(to, 0, sizeof(*to));
645*(to) = *(from);
646return 0;
647}
648
649int ASN1CALL
650encode_KerberosString(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KerberosString *data, size_t *size)
651{
652size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
653size_t l HEIMDAL_UNUSED_ATTRIBUTE;
654int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
655
656e = der_put_general_string(p, len, data, &l);
657if (e) return e;
658p -= l; len -= l; ret += l;
659
660e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
661if (e) return e;
662p -= l; len -= l; ret += l;
663
664*size = ret;
665return 0;
666}
667
668int ASN1CALL
669decode_KerberosString(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KerberosString *data, size_t *size)
670{
671size_t ret = 0;
672size_t l HEIMDAL_UNUSED_ATTRIBUTE;
673int e HEIMDAL_UNUSED_ATTRIBUTE;
674
675memset(data, 0, sizeof(*data));
676{
677size_t Top_datalen, Top_oldlen;
678Der_type Top_type;
679e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralString, &Top_datalen, &l);
680if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
681if(e) goto fail;
682p += l; len -= l; ret += l;
683Top_oldlen = len;
684if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
685len = Top_datalen;
686e = der_get_general_string(p, len, data, &l);
687if(e) goto fail;
688p += l; len -= l; ret += l;
689len = Top_oldlen - Top_datalen;
690}
691if(size) *size = ret;
692return 0;
693fail:
694free_KerberosString(data);
695return e;
696}
697
698void ASN1CALL
699free_KerberosString(KerberosString *data)
700{
701der_free_general_string(data);
702}
703
704size_t ASN1CALL
705length_KerberosString(const KerberosString *data)
706{
707size_t ret = 0;
708ret += der_length_general_string(data);
709ret += 1 + der_length_len (ret);
710return ret;
711}
712
713int ASN1CALL
714copy_KerberosString(const KerberosString *from, KerberosString *to)
715{
716memset(to, 0, sizeof(*to));
717if(der_copy_general_string(from, to)) goto fail;
718return 0;
719fail:
720free_KerberosString(to);
721return ENOMEM;
722}
723
724int ASN1CALL
725encode_Realm(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Realm *data, size_t *size)
726{
727size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
728size_t l HEIMDAL_UNUSED_ATTRIBUTE;
729int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
730
731e = der_put_general_string(p, len, data, &l);
732if (e) return e;
733p -= l; len -= l; ret += l;
734
735e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
736if (e) return e;
737p -= l; len -= l; ret += l;
738
739*size = ret;
740return 0;
741}
742
743int ASN1CALL
744decode_Realm(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Realm *data, size_t *size)
745{
746size_t ret = 0;
747size_t l HEIMDAL_UNUSED_ATTRIBUTE;
748int e HEIMDAL_UNUSED_ATTRIBUTE;
749
750memset(data, 0, sizeof(*data));
751{
752size_t Top_datalen, Top_oldlen;
753Der_type Top_type;
754e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralString, &Top_datalen, &l);
755if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
756if(e) goto fail;
757p += l; len -= l; ret += l;
758Top_oldlen = len;
759if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
760len = Top_datalen;
761e = der_get_general_string(p, len, data, &l);
762if(e) goto fail;
763p += l; len -= l; ret += l;
764len = Top_oldlen - Top_datalen;
765}
766if(size) *size = ret;
767return 0;
768fail:
769free_Realm(data);
770return e;
771}
772
773void ASN1CALL
774free_Realm(Realm *data)
775{
776der_free_general_string(data);
777}
778
779size_t ASN1CALL
780length_Realm(const Realm *data)
781{
782size_t ret = 0;
783ret += der_length_general_string(data);
784ret += 1 + der_length_len (ret);
785return ret;
786}
787
788int ASN1CALL
789copy_Realm(const Realm *from, Realm *to)
790{
791memset(to, 0, sizeof(*to));
792if(der_copy_general_string(from, to)) goto fail;
793return 0;
794fail:
795free_Realm(to);
796return ENOMEM;
797}
798
799int ASN1CALL
800encode_PrincipalName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PrincipalName *data, size_t *size)
801{
802size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
803size_t l HEIMDAL_UNUSED_ATTRIBUTE;
804int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
805
806/* name-string */
807{
808size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
809ret = 0;
810for(i = (int)(&(data)->name_string)->len - 1; i >= 0; --i) {
811size_t name_string_tag_tag_for_oldret = ret;
812ret = 0;
813e = der_put_general_string(p, len, &(&(data)->name_string)->val[i], &l);
814if (e) return e;
815p -= l; len -= l; ret += l;
816
817e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
818if (e) return e;
819p -= l; len -= l; ret += l;
820
821ret += name_string_tag_tag_for_oldret;
822}
823e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
824if (e) return e;
825p -= l; len -= l; ret += l;
826
827e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
828if (e) return e;
829p -= l; len -= l; ret += l;
830
831ret += Top_tag_oldret;
832}
833/* name-type */
834{
835size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
836ret = 0;
837e = encode_NAME_TYPE(p, len, &(data)->name_type, &l);
838if (e) return e;
839p -= l; len -= l; ret += l;
840
841e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
842if (e) return e;
843p -= l; len -= l; ret += l;
844
845ret += Top_tag_oldret;
846}
847e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
848if (e) return e;
849p -= l; len -= l; ret += l;
850
851*size = ret;
852return 0;
853}
854
855int ASN1CALL
856decode_PrincipalName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PrincipalName *data, size_t *size)
857{
858size_t ret = 0;
859size_t l HEIMDAL_UNUSED_ATTRIBUTE;
860int e HEIMDAL_UNUSED_ATTRIBUTE;
861
862memset(data, 0, sizeof(*data));
863{
864size_t Top_datalen, Top_oldlen;
865Der_type Top_type;
866e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
867if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
868if(e) goto fail;
869p += l; len -= l; ret += l;
870Top_oldlen = len;
871if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
872len = Top_datalen;
873{
874size_t name_type_datalen, name_type_oldlen;
875Der_type name_type_type;
876e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type_type, 0, &name_type_datalen, &l);
877if (e == 0 && name_type_type != CONS) { e = ASN1_BAD_ID; }
878if(e) goto fail;
879p += l; len -= l; ret += l;
880name_type_oldlen = len;
881if (name_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
882len = name_type_datalen;
883e = decode_NAME_TYPE(p, len, &(data)->name_type, &l);
884if(e) goto fail;
885p += l; len -= l; ret += l;
886len = name_type_oldlen - name_type_datalen;
887}
888{
889size_t name_string_datalen, name_string_oldlen;
890Der_type name_string_type;
891e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_string_type, 1, &name_string_datalen, &l);
892if (e == 0 && name_string_type != CONS) { e = ASN1_BAD_ID; }
893if(e) goto fail;
894p += l; len -= l; ret += l;
895name_string_oldlen = len;
896if (name_string_datalen > len) { e = ASN1_OVERRUN; goto fail; }
897len = name_string_datalen;
898{
899size_t name_string_Tag_datalen, name_string_Tag_oldlen;
900Der_type name_string_Tag_type;
901e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &name_string_Tag_type, UT_Sequence, &name_string_Tag_datalen, &l);
902if (e == 0 && name_string_Tag_type != CONS) { e = ASN1_BAD_ID; }
903if(e) goto fail;
904p += l; len -= l; ret += l;
905name_string_Tag_oldlen = len;
906if (name_string_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
907len = name_string_Tag_datalen;
908{
909size_t name_string_Tag_Tag_origlen = len;
910size_t name_string_Tag_Tag_oldret = ret;
911size_t name_string_Tag_Tag_olen = 0;
912void *name_string_Tag_Tag_tmp;
913ret = 0;
914(&(data)->name_string)->len = 0;
915(&(data)->name_string)->val = NULL;
916while(ret < name_string_Tag_Tag_origlen) {
917size_t name_string_Tag_Tag_nlen = name_string_Tag_Tag_olen + sizeof(*((&(data)->name_string)->val));
918if (name_string_Tag_Tag_olen > name_string_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
919name_string_Tag_Tag_olen = name_string_Tag_Tag_nlen;
920name_string_Tag_Tag_tmp = realloc((&(data)->name_string)->val, name_string_Tag_Tag_olen);
921if (name_string_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
922(&(data)->name_string)->val = name_string_Tag_Tag_tmp;
923{
924size_t name_string_Tag_Tag_s_of_datalen, name_string_Tag_Tag_s_of_oldlen;
925Der_type name_string_Tag_Tag_s_of_type;
926e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &name_string_Tag_Tag_s_of_type, UT_GeneralString, &name_string_Tag_Tag_s_of_datalen, &l);
927if (e == 0 && name_string_Tag_Tag_s_of_type != PRIM) { e = ASN1_BAD_ID; }
928if(e) goto fail;
929p += l; len -= l; ret += l;
930name_string_Tag_Tag_s_of_oldlen = len;
931if (name_string_Tag_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
932len = name_string_Tag_Tag_s_of_datalen;
933e = der_get_general_string(p, len, &(&(data)->name_string)->val[(&(data)->name_string)->len], &l);
934if(e) goto fail;
935p += l; len -= l; ret += l;
936len = name_string_Tag_Tag_s_of_oldlen - name_string_Tag_Tag_s_of_datalen;
937}
938(&(data)->name_string)->len++;
939len = name_string_Tag_Tag_origlen - ret;
940}
941ret += name_string_Tag_Tag_oldret;
942}
943len = name_string_Tag_oldlen - name_string_Tag_datalen;
944}
945len = name_string_oldlen - name_string_datalen;
946}
947len = Top_oldlen - Top_datalen;
948}
949if(size) *size = ret;
950return 0;
951fail:
952free_PrincipalName(data);
953return e;
954}
955
956void ASN1CALL
957free_PrincipalName(PrincipalName *data)
958{
959free_NAME_TYPE(&(data)->name_type);
960while((&(data)->name_string)->len){
961der_free_general_string(&(&(data)->name_string)->val[(&(data)->name_string)->len-1]);
962(&(data)->name_string)->len--;
963}
964free((&(data)->name_string)->val);
965(&(data)->name_string)->val = NULL;
966}
967
968size_t ASN1CALL
969length_PrincipalName(const PrincipalName *data)
970{
971size_t ret = 0;
972{
973size_t Top_tag_oldret = ret;
974ret = 0;
975ret += length_NAME_TYPE(&(data)->name_type);
976ret += 1 + der_length_len (ret);
977ret += Top_tag_oldret;
978}
979{
980size_t Top_tag_oldret = ret;
981ret = 0;
982{
983size_t name_string_tag_tag_oldret = ret;
984unsigned int n_name_string_tag_tag;
985ret = 0;
986for(n_name_string_tag_tag = (&(data)->name_string)->len; n_name_string_tag_tag > 0; --n_name_string_tag_tag){
987size_t name_string_tag_tag_for_oldret = ret;
988ret = 0;
989ret += der_length_general_string(&(&(data)->name_string)->val[n_name_string_tag_tag - 1]);
990ret += 1 + der_length_len (ret);
991ret += name_string_tag_tag_for_oldret;
992}
993ret += name_string_tag_tag_oldret;
994}
995ret += 1 + der_length_len (ret);
996ret += 1 + der_length_len (ret);
997ret += Top_tag_oldret;
998}
999ret += 1 + der_length_len (ret);
1000return ret;
1001}
1002
1003int ASN1CALL
1004copy_PrincipalName(const PrincipalName *from, PrincipalName *to)
1005{
1006memset(to, 0, sizeof(*to));
1007if(copy_NAME_TYPE(&(from)->name_type, &(to)->name_type)) goto fail;
1008if(((&(to)->name_string)->val = malloc((&(from)->name_string)->len * sizeof(*(&(to)->name_string)->val))) == NULL && (&(from)->name_string)->len != 0)
1009goto fail;
1010for((&(to)->name_string)->len = 0; (&(to)->name_string)->len < (&(from)->name_string)->len; (&(to)->name_string)->len++){
1011if(der_copy_general_string(&(&(from)->name_string)->val[(&(to)->name_string)->len], &(&(to)->name_string)->val[(&(to)->name_string)->len])) goto fail;
1012}
1013return 0;
1014fail:
1015free_PrincipalName(to);
1016return ENOMEM;
1017}
1018
1019int ASN1CALL
1020encode_Principal(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Principal *data, size_t *size)
1021{
1022size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1023size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1024int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1025
1026/* realm */
1027{
1028size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1029ret = 0;
1030e = encode_Realm(p, len, &(data)->realm, &l);
1031if (e) return e;
1032p -= l; len -= l; ret += l;
1033
1034e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1035if (e) return e;
1036p -= l; len -= l; ret += l;
1037
1038ret += Top_tag_oldret;
1039}
1040/* name */
1041{
1042size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1043ret = 0;
1044e = encode_PrincipalName(p, len, &(data)->name, &l);
1045if (e) return e;
1046p -= l; len -= l; ret += l;
1047
1048e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1049if (e) return e;
1050p -= l; len -= l; ret += l;
1051
1052ret += Top_tag_oldret;
1053}
1054e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1055if (e) return e;
1056p -= l; len -= l; ret += l;
1057
1058*size = ret;
1059return 0;
1060}
1061
1062int ASN1CALL
1063decode_Principal(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Principal *data, size_t *size)
1064{
1065size_t ret = 0;
1066size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1067int e HEIMDAL_UNUSED_ATTRIBUTE;
1068
1069memset(data, 0, sizeof(*data));
1070{
1071size_t Top_datalen, Top_oldlen;
1072Der_type Top_type;
1073e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1074if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1075if(e) goto fail;
1076p += l; len -= l; ret += l;
1077Top_oldlen = len;
1078if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1079len = Top_datalen;
1080{
1081size_t name_datalen, name_oldlen;
1082Der_type name_type;
1083e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type, 0, &name_datalen, &l);
1084if (e == 0 && name_type != CONS) { e = ASN1_BAD_ID; }
1085if(e) goto fail;
1086p += l; len -= l; ret += l;
1087name_oldlen = len;
1088if (name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1089len = name_datalen;
1090e = decode_PrincipalName(p, len, &(data)->name, &l);
1091if(e) goto fail;
1092p += l; len -= l; ret += l;
1093len = name_oldlen - name_datalen;
1094}
1095{
1096size_t realm_datalen, realm_oldlen;
1097Der_type realm_type;
1098e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 1, &realm_datalen, &l);
1099if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
1100if(e) goto fail;
1101p += l; len -= l; ret += l;
1102realm_oldlen = len;
1103if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1104len = realm_datalen;
1105e = decode_Realm(p, len, &(data)->realm, &l);
1106if(e) goto fail;
1107p += l; len -= l; ret += l;
1108len = realm_oldlen - realm_datalen;
1109}
1110len = Top_oldlen - Top_datalen;
1111}
1112if(size) *size = ret;
1113return 0;
1114fail:
1115free_Principal(data);
1116return e;
1117}
1118
1119void ASN1CALL
1120free_Principal(Principal *data)
1121{
1122free_PrincipalName(&(data)->name);
1123free_Realm(&(data)->realm);
1124}
1125
1126size_t ASN1CALL
1127length_Principal(const Principal *data)
1128{
1129size_t ret = 0;
1130{
1131size_t Top_tag_oldret = ret;
1132ret = 0;
1133ret += length_PrincipalName(&(data)->name);
1134ret += 1 + der_length_len (ret);
1135ret += Top_tag_oldret;
1136}
1137{
1138size_t Top_tag_oldret = ret;
1139ret = 0;
1140ret += length_Realm(&(data)->realm);
1141ret += 1 + der_length_len (ret);
1142ret += Top_tag_oldret;
1143}
1144ret += 1 + der_length_len (ret);
1145return ret;
1146}
1147
1148int ASN1CALL
1149copy_Principal(const Principal *from, Principal *to)
1150{
1151memset(to, 0, sizeof(*to));
1152if(copy_PrincipalName(&(from)->name, &(to)->name)) goto fail;
1153if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
1154return 0;
1155fail:
1156free_Principal(to);
1157return ENOMEM;
1158}
1159
1160int ASN1CALL
1161encode_Principals(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Principals *data, size_t *size)
1162{
1163size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1164size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1165int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1166
1167for(i = (int)(data)->len - 1; i >= 0; --i) {
1168size_t Top_tag_for_oldret = ret;
1169ret = 0;
1170e = encode_Principal(p, len, &(data)->val[i], &l);
1171if (e) return e;
1172p -= l; len -= l; ret += l;
1173
1174ret += Top_tag_for_oldret;
1175}
1176e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1177if (e) return e;
1178p -= l; len -= l; ret += l;
1179
1180*size = ret;
1181return 0;
1182}
1183
1184int ASN1CALL
1185decode_Principals(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Principals *data, size_t *size)
1186{
1187size_t ret = 0;
1188size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1189int e HEIMDAL_UNUSED_ATTRIBUTE;
1190
1191memset(data, 0, sizeof(*data));
1192{
1193size_t Top_datalen, Top_oldlen;
1194Der_type Top_type;
1195e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1196if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1197if(e) goto fail;
1198p += l; len -= l; ret += l;
1199Top_oldlen = len;
1200if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1201len = Top_datalen;
1202{
1203size_t Top_Tag_origlen = len;
1204size_t Top_Tag_oldret = ret;
1205size_t Top_Tag_olen = 0;
1206void *Top_Tag_tmp;
1207ret = 0;
1208(data)->len = 0;
1209(data)->val = NULL;
1210while(ret < Top_Tag_origlen) {
1211size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1212if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1213Top_Tag_olen = Top_Tag_nlen;
1214Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1215if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1216(data)->val = Top_Tag_tmp;
1217e = decode_Principal(p, len, &(data)->val[(data)->len], &l);
1218if(e) goto fail;
1219p += l; len -= l; ret += l;
1220(data)->len++;
1221len = Top_Tag_origlen - ret;
1222}
1223ret += Top_Tag_oldret;
1224}
1225len = Top_oldlen - Top_datalen;
1226}
1227if(size) *size = ret;
1228return 0;
1229fail:
1230free_Principals(data);
1231return e;
1232}
1233
1234void ASN1CALL
1235free_Principals(Principals *data)
1236{
1237while((data)->len){
1238free_Principal(&(data)->val[(data)->len-1]);
1239(data)->len--;
1240}
1241free((data)->val);
1242(data)->val = NULL;
1243}
1244
1245size_t ASN1CALL
1246length_Principals(const Principals *data)
1247{
1248size_t ret = 0;
1249{
1250size_t Top_tag_oldret = ret;
1251unsigned int n_Top_tag;
1252ret = 0;
1253for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
1254size_t Top_tag_for_oldret = ret;
1255ret = 0;
1256ret += length_Principal(&(data)->val[n_Top_tag - 1]);
1257ret += Top_tag_for_oldret;
1258}
1259ret += Top_tag_oldret;
1260}
1261ret += 1 + der_length_len (ret);
1262return ret;
1263}
1264
1265int ASN1CALL
1266copy_Principals(const Principals *from, Principals *to)
1267{
1268memset(to, 0, sizeof(*to));
1269if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1270goto fail;
1271for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1272if(copy_Principal(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1273}
1274return 0;
1275fail:
1276free_Principals(to);
1277return ENOMEM;
1278}
1279
1280int ASN1CALL
1281add_Principals(Principals *data, const Principal *element)
1282{
1283int ret;
1284void *ptr;
1285
1286ptr = realloc(data->val,
1287 (data->len + 1) * sizeof(data->val[0]));
1288if (ptr == NULL) return ENOMEM;
1289data->val = ptr;
1290
1291ret = copy_Principal(element, &data->val[data->len]);
1292if (ret) return ret;
1293data->len++;
1294return 0;
1295}
1296
1297int ASN1CALL
1298remove_Principals(Principals *data, unsigned int element)
1299{
1300void *ptr;
1301
1302if (data->len == 0 || element >= data->len)
1303 return ASN1_OVERRUN;
1304free_Principal(&data->val[element]);
1305data->len--;
1306if (element < data->len)
1307 memmove(&data->val[element], &data->val[element + 1],
1308 sizeof(data->val[0]) * (data->len - element));
1309ptr = realloc(data->val, data->len * sizeof(data->val[0]));
1310if (ptr != NULL || data->len == 0) data->val = ptr;
1311return 0;
1312}
1313
1314int ASN1CALL
1315encode_HostAddress(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HostAddress *data, size_t *size)
1316{
1317size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1318size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1319int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1320
1321/* address */
1322{
1323size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1324ret = 0;
1325e = der_put_octet_string(p, len, &(data)->address, &l);
1326if (e) return e;
1327p -= l; len -= l; ret += l;
1328
1329e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1330if (e) return e;
1331p -= l; len -= l; ret += l;
1332
1333e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1334if (e) return e;
1335p -= l; len -= l; ret += l;
1336
1337ret += Top_tag_oldret;
1338}
1339/* addr-type */
1340{
1341size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1342ret = 0;
1343e = encode_krb5int32(p, len, &(data)->addr_type, &l);
1344if (e) return e;
1345p -= l; len -= l; ret += l;
1346
1347e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1348if (e) return e;
1349p -= l; len -= l; ret += l;
1350
1351ret += Top_tag_oldret;
1352}
1353e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1354if (e) return e;
1355p -= l; len -= l; ret += l;
1356
1357*size = ret;
1358return 0;
1359}
1360
1361int ASN1CALL
1362decode_HostAddress(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HostAddress *data, size_t *size)
1363{
1364size_t ret = 0;
1365size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1366int e HEIMDAL_UNUSED_ATTRIBUTE;
1367
1368memset(data, 0, sizeof(*data));
1369{
1370size_t Top_datalen, Top_oldlen;
1371Der_type Top_type;
1372e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1373if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1374if(e) goto fail;
1375p += l; len -= l; ret += l;
1376Top_oldlen = len;
1377if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1378len = Top_datalen;
1379{
1380size_t addr_type_datalen, addr_type_oldlen;
1381Der_type addr_type_type;
1382e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &addr_type_type, 0, &addr_type_datalen, &l);
1383if (e == 0 && addr_type_type != CONS) { e = ASN1_BAD_ID; }
1384if(e) goto fail;
1385p += l; len -= l; ret += l;
1386addr_type_oldlen = len;
1387if (addr_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1388len = addr_type_datalen;
1389e = decode_krb5int32(p, len, &(data)->addr_type, &l);
1390if(e) goto fail;
1391p += l; len -= l; ret += l;
1392len = addr_type_oldlen - addr_type_datalen;
1393}
1394{
1395size_t address_datalen, address_oldlen;
1396Der_type address_type;
1397e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &address_type, 1, &address_datalen, &l);
1398if (e == 0 && address_type != CONS) { e = ASN1_BAD_ID; }
1399if(e) goto fail;
1400p += l; len -= l; ret += l;
1401address_oldlen = len;
1402if (address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1403len = address_datalen;
1404{
1405size_t address_Tag_datalen, address_Tag_oldlen;
1406Der_type address_Tag_type;
1407e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &address_Tag_type, UT_OctetString, &address_Tag_datalen, &l);
1408if (e == 0 && address_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1409if(e) goto fail;
1410p += l; len -= l; ret += l;
1411address_Tag_oldlen = len;
1412if (address_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1413len = address_Tag_datalen;
1414e = der_get_octet_string(p, len, &(data)->address, &l);
1415if(e) goto fail;
1416p += l; len -= l; ret += l;
1417len = address_Tag_oldlen - address_Tag_datalen;
1418}
1419len = address_oldlen - address_datalen;
1420}
1421len = Top_oldlen - Top_datalen;
1422}
1423if(size) *size = ret;
1424return 0;
1425fail:
1426free_HostAddress(data);
1427return e;
1428}
1429
1430void ASN1CALL
1431free_HostAddress(HostAddress *data)
1432{
1433free_krb5int32(&(data)->addr_type);
1434der_free_octet_string(&(data)->address);
1435}
1436
1437size_t ASN1CALL
1438length_HostAddress(const HostAddress *data)
1439{
1440size_t ret = 0;
1441{
1442size_t Top_tag_oldret = ret;
1443ret = 0;
1444ret += length_krb5int32(&(data)->addr_type);
1445ret += 1 + der_length_len (ret);
1446ret += Top_tag_oldret;
1447}
1448{
1449size_t Top_tag_oldret = ret;
1450ret = 0;
1451ret += der_length_octet_string(&(data)->address);
1452ret += 1 + der_length_len (ret);
1453ret += 1 + der_length_len (ret);
1454ret += Top_tag_oldret;
1455}
1456ret += 1 + der_length_len (ret);
1457return ret;
1458}
1459
1460int ASN1CALL
1461copy_HostAddress(const HostAddress *from, HostAddress *to)
1462{
1463memset(to, 0, sizeof(*to));
1464if(copy_krb5int32(&(from)->addr_type, &(to)->addr_type)) goto fail;
1465if(der_copy_octet_string(&(from)->address, &(to)->address)) goto fail;
1466return 0;
1467fail:
1468free_HostAddress(to);
1469return ENOMEM;
1470}
1471
1472int ASN1CALL
1473encode_HostAddresses(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const HostAddresses *data, size_t *size)
1474{
1475size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1476size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1477int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1478
1479for(i = (int)(data)->len - 1; i >= 0; --i) {
1480size_t Top_tag_for_oldret = ret;
1481ret = 0;
1482e = encode_HostAddress(p, len, &(data)->val[i], &l);
1483if (e) return e;
1484p -= l; len -= l; ret += l;
1485
1486ret += Top_tag_for_oldret;
1487}
1488e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1489if (e) return e;
1490p -= l; len -= l; ret += l;
1491
1492*size = ret;
1493return 0;
1494}
1495
1496int ASN1CALL
1497decode_HostAddresses(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, HostAddresses *data, size_t *size)
1498{
1499size_t ret = 0;
1500size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1501int e HEIMDAL_UNUSED_ATTRIBUTE;
1502
1503memset(data, 0, sizeof(*data));
1504{
1505size_t Top_datalen, Top_oldlen;
1506Der_type Top_type;
1507e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1508if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1509if(e) goto fail;
1510p += l; len -= l; ret += l;
1511Top_oldlen = len;
1512if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1513len = Top_datalen;
1514{
1515size_t Top_Tag_origlen = len;
1516size_t Top_Tag_oldret = ret;
1517size_t Top_Tag_olen = 0;
1518void *Top_Tag_tmp;
1519ret = 0;
1520(data)->len = 0;
1521(data)->val = NULL;
1522while(ret < Top_Tag_origlen) {
1523size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1524if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1525Top_Tag_olen = Top_Tag_nlen;
1526Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1527if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1528(data)->val = Top_Tag_tmp;
1529e = decode_HostAddress(p, len, &(data)->val[(data)->len], &l);
1530if(e) goto fail;
1531p += l; len -= l; ret += l;
1532(data)->len++;
1533len = Top_Tag_origlen - ret;
1534}
1535ret += Top_Tag_oldret;
1536}
1537len = Top_oldlen - Top_datalen;
1538}
1539if(size) *size = ret;
1540return 0;
1541fail:
1542free_HostAddresses(data);
1543return e;
1544}
1545
1546void ASN1CALL
1547free_HostAddresses(HostAddresses *data)
1548{
1549while((data)->len){
1550free_HostAddress(&(data)->val[(data)->len-1]);
1551(data)->len--;
1552}
1553free((data)->val);
1554(data)->val = NULL;
1555}
1556
1557size_t ASN1CALL
1558length_HostAddresses(const HostAddresses *data)
1559{
1560size_t ret = 0;
1561{
1562size_t Top_tag_oldret = ret;
1563unsigned int n_Top_tag;
1564ret = 0;
1565for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
1566size_t Top_tag_for_oldret = ret;
1567ret = 0;
1568ret += length_HostAddress(&(data)->val[n_Top_tag - 1]);
1569ret += Top_tag_for_oldret;
1570}
1571ret += Top_tag_oldret;
1572}
1573ret += 1 + der_length_len (ret);
1574return ret;
1575}
1576
1577int ASN1CALL
1578copy_HostAddresses(const HostAddresses *from, HostAddresses *to)
1579{
1580memset(to, 0, sizeof(*to));
1581if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1582goto fail;
1583for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1584if(copy_HostAddress(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1585}
1586return 0;
1587fail:
1588free_HostAddresses(to);
1589return ENOMEM;
1590}
1591
1592int ASN1CALL
1593encode_KerberosTime(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KerberosTime *data, size_t *size)
1594{
1595size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1596size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1597int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1598
1599e = der_put_generalized_time(p, len, data, &l);
1600if (e) return e;
1601p -= l; len -= l; ret += l;
1602
1603e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, &l);
1604if (e) return e;
1605p -= l; len -= l; ret += l;
1606
1607*size = ret;
1608return 0;
1609}
1610
1611int ASN1CALL
1612decode_KerberosTime(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KerberosTime *data, size_t *size)
1613{
1614size_t ret = 0;
1615size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1616int e HEIMDAL_UNUSED_ATTRIBUTE;
1617
1618memset(data, 0, sizeof(*data));
1619{
1620size_t Top_datalen, Top_oldlen;
1621Der_type Top_type;
1622e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralizedTime, &Top_datalen, &l);
1623if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
1624if(e) goto fail;
1625p += l; len -= l; ret += l;
1626Top_oldlen = len;
1627if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1628len = Top_datalen;
1629e = der_get_generalized_time(p, len, data, &l);
1630if(e) goto fail;
1631p += l; len -= l; ret += l;
1632len = Top_oldlen - Top_datalen;
1633}
1634if(size) *size = ret;
1635return 0;
1636fail:
1637free_KerberosTime(data);
1638return e;
1639}
1640
1641void ASN1CALL
1642free_KerberosTime(KerberosTime *data)
1643{
1644}
1645
1646size_t ASN1CALL
1647length_KerberosTime(const KerberosTime *data)
1648{
1649size_t ret = 0;
1650ret += der_length_generalized_time(data);
1651ret += 1 + der_length_len (ret);
1652return ret;
1653}
1654
1655int ASN1CALL
1656copy_KerberosTime(const KerberosTime *from, KerberosTime *to)
1657{
1658memset(to, 0, sizeof(*to));
1659*(to) = *(from);
1660return 0;
1661}
1662
1663int ASN1CALL
1664encode_AuthorizationDataElement(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorizationDataElement *data, size_t *size)
1665{
1666size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1667size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1668int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1669
1670/* ad-data */
1671{
1672size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1673ret = 0;
1674e = der_put_octet_string(p, len, &(data)->ad_data, &l);
1675if (e) return e;
1676p -= l; len -= l; ret += l;
1677
1678e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1679if (e) return e;
1680p -= l; len -= l; ret += l;
1681
1682e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1683if (e) return e;
1684p -= l; len -= l; ret += l;
1685
1686ret += Top_tag_oldret;
1687}
1688/* ad-type */
1689{
1690size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1691ret = 0;
1692e = encode_krb5int32(p, len, &(data)->ad_type, &l);
1693if (e) return e;
1694p -= l; len -= l; ret += l;
1695
1696e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1697if (e) return e;
1698p -= l; len -= l; ret += l;
1699
1700ret += Top_tag_oldret;
1701}
1702e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1703if (e) return e;
1704p -= l; len -= l; ret += l;
1705
1706*size = ret;
1707return 0;
1708}
1709
1710int ASN1CALL
1711decode_AuthorizationDataElement(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorizationDataElement *data, size_t *size)
1712{
1713size_t ret = 0;
1714size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1715int e HEIMDAL_UNUSED_ATTRIBUTE;
1716
1717memset(data, 0, sizeof(*data));
1718{
1719size_t Top_datalen, Top_oldlen;
1720Der_type Top_type;
1721e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1722if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1723if(e) goto fail;
1724p += l; len -= l; ret += l;
1725Top_oldlen = len;
1726if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1727len = Top_datalen;
1728{
1729size_t ad_type_datalen, ad_type_oldlen;
1730Der_type ad_type_type;
1731e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_type_type, 0, &ad_type_datalen, &l);
1732if (e == 0 && ad_type_type != CONS) { e = ASN1_BAD_ID; }
1733if(e) goto fail;
1734p += l; len -= l; ret += l;
1735ad_type_oldlen = len;
1736if (ad_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1737len = ad_type_datalen;
1738e = decode_krb5int32(p, len, &(data)->ad_type, &l);
1739if(e) goto fail;
1740p += l; len -= l; ret += l;
1741len = ad_type_oldlen - ad_type_datalen;
1742}
1743{
1744size_t ad_data_datalen, ad_data_oldlen;
1745Der_type ad_data_type;
1746e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_data_type, 1, &ad_data_datalen, &l);
1747if (e == 0 && ad_data_type != CONS) { e = ASN1_BAD_ID; }
1748if(e) goto fail;
1749p += l; len -= l; ret += l;
1750ad_data_oldlen = len;
1751if (ad_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1752len = ad_data_datalen;
1753{
1754size_t ad_data_Tag_datalen, ad_data_Tag_oldlen;
1755Der_type ad_data_Tag_type;
1756e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ad_data_Tag_type, UT_OctetString, &ad_data_Tag_datalen, &l);
1757if (e == 0 && ad_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
1758if(e) goto fail;
1759p += l; len -= l; ret += l;
1760ad_data_Tag_oldlen = len;
1761if (ad_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1762len = ad_data_Tag_datalen;
1763e = der_get_octet_string(p, len, &(data)->ad_data, &l);
1764if(e) goto fail;
1765p += l; len -= l; ret += l;
1766len = ad_data_Tag_oldlen - ad_data_Tag_datalen;
1767}
1768len = ad_data_oldlen - ad_data_datalen;
1769}
1770len = Top_oldlen - Top_datalen;
1771}
1772if(size) *size = ret;
1773return 0;
1774fail:
1775free_AuthorizationDataElement(data);
1776return e;
1777}
1778
1779void ASN1CALL
1780free_AuthorizationDataElement(AuthorizationDataElement *data)
1781{
1782free_krb5int32(&(data)->ad_type);
1783der_free_octet_string(&(data)->ad_data);
1784}
1785
1786size_t ASN1CALL
1787length_AuthorizationDataElement(const AuthorizationDataElement *data)
1788{
1789size_t ret = 0;
1790{
1791size_t Top_tag_oldret = ret;
1792ret = 0;
1793ret += length_krb5int32(&(data)->ad_type);
1794ret += 1 + der_length_len (ret);
1795ret += Top_tag_oldret;
1796}
1797{
1798size_t Top_tag_oldret = ret;
1799ret = 0;
1800ret += der_length_octet_string(&(data)->ad_data);
1801ret += 1 + der_length_len (ret);
1802ret += 1 + der_length_len (ret);
1803ret += Top_tag_oldret;
1804}
1805ret += 1 + der_length_len (ret);
1806return ret;
1807}
1808
1809int ASN1CALL
1810copy_AuthorizationDataElement(const AuthorizationDataElement *from, AuthorizationDataElement *to)
1811{
1812memset(to, 0, sizeof(*to));
1813if(copy_krb5int32(&(from)->ad_type, &(to)->ad_type)) goto fail;
1814if(der_copy_octet_string(&(from)->ad_data, &(to)->ad_data)) goto fail;
1815return 0;
1816fail:
1817free_AuthorizationDataElement(to);
1818return ENOMEM;
1819}
1820
1821int ASN1CALL
1822encode_AuthorizationData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorizationData *data, size_t *size)
1823{
1824size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1825size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1826int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1827
1828for(i = (int)(data)->len - 1; i >= 0; --i) {
1829size_t Top_tag_for_oldret = ret;
1830ret = 0;
1831e = encode_AuthorizationDataElement(p, len, &(data)->val[i], &l);
1832if (e) return e;
1833p -= l; len -= l; ret += l;
1834
1835ret += Top_tag_for_oldret;
1836}
1837e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1838if (e) return e;
1839p -= l; len -= l; ret += l;
1840
1841*size = ret;
1842return 0;
1843}
1844
1845int ASN1CALL
1846decode_AuthorizationData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorizationData *data, size_t *size)
1847{
1848size_t ret = 0;
1849size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1850int e HEIMDAL_UNUSED_ATTRIBUTE;
1851
1852memset(data, 0, sizeof(*data));
1853{
1854size_t Top_datalen, Top_oldlen;
1855Der_type Top_type;
1856e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1857if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1858if(e) goto fail;
1859p += l; len -= l; ret += l;
1860Top_oldlen = len;
1861if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
1862len = Top_datalen;
1863{
1864size_t Top_Tag_origlen = len;
1865size_t Top_Tag_oldret = ret;
1866size_t Top_Tag_olen = 0;
1867void *Top_Tag_tmp;
1868ret = 0;
1869(data)->len = 0;
1870(data)->val = NULL;
1871while(ret < Top_Tag_origlen) {
1872size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1873if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1874Top_Tag_olen = Top_Tag_nlen;
1875Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1876if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1877(data)->val = Top_Tag_tmp;
1878e = decode_AuthorizationDataElement(p, len, &(data)->val[(data)->len], &l);
1879if(e) goto fail;
1880p += l; len -= l; ret += l;
1881(data)->len++;
1882len = Top_Tag_origlen - ret;
1883}
1884ret += Top_Tag_oldret;
1885}
1886len = Top_oldlen - Top_datalen;
1887}
1888if(size) *size = ret;
1889return 0;
1890fail:
1891free_AuthorizationData(data);
1892return e;
1893}
1894
1895void ASN1CALL
1896free_AuthorizationData(AuthorizationData *data)
1897{
1898while((data)->len){
1899free_AuthorizationDataElement(&(data)->val[(data)->len-1]);
1900(data)->len--;
1901}
1902free((data)->val);
1903(data)->val = NULL;
1904}
1905
1906size_t ASN1CALL
1907length_AuthorizationData(const AuthorizationData *data)
1908{
1909size_t ret = 0;
1910{
1911size_t Top_tag_oldret = ret;
1912unsigned int n_Top_tag;
1913ret = 0;
1914for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
1915size_t Top_tag_for_oldret = ret;
1916ret = 0;
1917ret += length_AuthorizationDataElement(&(data)->val[n_Top_tag - 1]);
1918ret += Top_tag_for_oldret;
1919}
1920ret += Top_tag_oldret;
1921}
1922ret += 1 + der_length_len (ret);
1923return ret;
1924}
1925
1926int ASN1CALL
1927copy_AuthorizationData(const AuthorizationData *from, AuthorizationData *to)
1928{
1929memset(to, 0, sizeof(*to));
1930if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1931goto fail;
1932for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1933if(copy_AuthorizationDataElement(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1934}
1935return 0;
1936fail:
1937free_AuthorizationData(to);
1938return ENOMEM;
1939}
1940
1941int ASN1CALL
1942add_AuthorizationData(AuthorizationData *data, const AuthorizationDataElement *element)
1943{
1944int ret;
1945void *ptr;
1946
1947ptr = realloc(data->val,
1948 (data->len + 1) * sizeof(data->val[0]));
1949if (ptr == NULL) return ENOMEM;
1950data->val = ptr;
1951
1952ret = copy_AuthorizationDataElement(element, &data->val[data->len]);
1953if (ret) return ret;
1954data->len++;
1955return 0;
1956}
1957
1958int ASN1CALL
1959remove_AuthorizationData(AuthorizationData *data, unsigned int element)
1960{
1961void *ptr;
1962
1963if (data->len == 0 || element >= data->len)
1964 return ASN1_OVERRUN;
1965free_AuthorizationDataElement(&data->val[element]);
1966data->len--;
1967if (element < data->len)
1968 memmove(&data->val[element], &data->val[element + 1],
1969 sizeof(data->val[0]) * (data->len - element));
1970ptr = realloc(data->val, data->len * sizeof(data->val[0]));
1971if (ptr != NULL || data->len == 0) data->val = ptr;
1972return 0;
1973}
1974
1975int ASN1CALL
1976encode_APOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const APOptions *data, size_t *size)
1977{
1978size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1979size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1980int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1981
1982{
1983unsigned char c = 0;
1984if (len < 1) return ASN1_OVERFLOW;
1985*p-- = c; len--; ret++;
1986c = 0;
1987if (len < 1) return ASN1_OVERFLOW;
1988*p-- = c; len--; ret++;
1989c = 0;
1990if (len < 1) return ASN1_OVERFLOW;
1991*p-- = c; len--; ret++;
1992c = 0;
1993if((data)->mutual_required) {
1994c |= 1<<5;
1995}
1996if((data)->use_session_key) {
1997c |= 1<<6;
1998}
1999if((data)->reserved) {
2000c |= 1<<7;
2001}
2002if (len < 1) return ASN1_OVERFLOW;
2003*p-- = c; len--; ret++;
2004if (len < 1) return ASN1_OVERFLOW;
2005*p-- = 0;
2006len -= 1;
2007ret += 1;
2008}
2009
2010e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2011if (e) return e;
2012p -= l; len -= l; ret += l;
2013
2014*size = ret;
2015return 0;
2016}
2017
2018int ASN1CALL
2019decode_APOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, APOptions *data, size_t *size)
2020{
2021size_t ret = 0;
2022size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2023int e HEIMDAL_UNUSED_ATTRIBUTE;
2024
2025memset(data, 0, sizeof(*data));
2026{
2027size_t Top_datalen, Top_oldlen;
2028Der_type Top_type;
2029e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
2030if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2031if(e) goto fail;
2032p += l; len -= l; ret += l;
2033Top_oldlen = len;
2034if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2035len = Top_datalen;
2036if (len < 1) return ASN1_OVERRUN;
2037p++; len--; ret++;
2038do {
2039if (len < 1) break;
2040(data)->reserved = (*p >> 7) & 1;
2041(data)->use_session_key = (*p >> 6) & 1;
2042(data)->mutual_required = (*p >> 5) & 1;
2043} while(0);
2044p += len; ret += len;
2045len = Top_oldlen - Top_datalen;
2046}
2047if(size) *size = ret;
2048return 0;
2049fail:
2050free_APOptions(data);
2051return e;
2052}
2053
2054void ASN1CALL
2055free_APOptions(APOptions *data)
2056{
2057}
2058
2059size_t ASN1CALL
2060length_APOptions(const APOptions *data)
2061{
2062size_t ret = 0;
2063ret += 5;
2064ret += 1 + der_length_len (ret);
2065return ret;
2066}
2067
2068int ASN1CALL
2069copy_APOptions(const APOptions *from, APOptions *to)
2070{
2071memset(to, 0, sizeof(*to));
2072*(to) = *(from);
2073return 0;
2074}
2075
2076unsigned APOptions2int(APOptions f)
2077{
2078unsigned r = 0;
2079if(f.reserved) r |= (1U << 0);
2080if(f.use_session_key) r |= (1U << 1);
2081if(f.mutual_required) r |= (1U << 2);
2082return r;
2083}
2084
2085APOptions int2APOptions(unsigned n)
2086{
2087 APOptions flags;
2088
2089 memset(&flags, 0, sizeof(flags));
2090
2091 flags.reserved = (n >> 0) & 1;
2092 flags.use_session_key = (n >> 1) & 1;
2093 flags.mutual_required = (n >> 2) & 1;
2094 return flags;
2095}
2096
2097static struct units APOptions_units[] = {
2098 {"mutual-required", 1U << 2},
2099 {"use-session-key", 1U << 1},
2100 {"reserved", 1U << 0},
2101 {NULL, 0}
2102};
2103
2104const struct units * asn1_APOptions_units(void){
2105return APOptions_units;
2106}
2107
2108int ASN1CALL
2109encode_TicketFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TicketFlags *data, size_t *size)
2110{
2111size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2112size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2113int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2114
2115{
2116unsigned char c = 0;
2117if (len < 1) return ASN1_OVERFLOW;
2118*p-- = c; len--; ret++;
2119c = 0;
2120if((data)->anonymous) {
2121c |= 1<<7;
2122}
2123if (len < 1) return ASN1_OVERFLOW;
2124*p-- = c; len--; ret++;
2125c = 0;
2126if((data)->enc_pa_rep) {
2127c |= 1<<0;
2128}
2129if((data)->ok_as_delegate) {
2130c |= 1<<2;
2131}
2132if((data)->transited_policy_checked) {
2133c |= 1<<3;
2134}
2135if((data)->hw_authent) {
2136c |= 1<<4;
2137}
2138if((data)->pre_authent) {
2139c |= 1<<5;
2140}
2141if((data)->initial) {
2142c |= 1<<6;
2143}
2144if((data)->renewable) {
2145c |= 1<<7;
2146}
2147if (len < 1) return ASN1_OVERFLOW;
2148*p-- = c; len--; ret++;
2149c = 0;
2150if((data)->invalid) {
2151c |= 1<<0;
2152}
2153if((data)->postdated) {
2154c |= 1<<1;
2155}
2156if((data)->may_postdate) {
2157c |= 1<<2;
2158}
2159if((data)->proxy) {
2160c |= 1<<3;
2161}
2162if((data)->proxiable) {
2163c |= 1<<4;
2164}
2165if((data)->forwarded) {
2166c |= 1<<5;
2167}
2168if((data)->forwardable) {
2169c |= 1<<6;
2170}
2171if((data)->reserved) {
2172c |= 1<<7;
2173}
2174if (len < 1) return ASN1_OVERFLOW;
2175*p-- = c; len--; ret++;
2176if (len < 1) return ASN1_OVERFLOW;
2177*p-- = 0;
2178len -= 1;
2179ret += 1;
2180}
2181
2182e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2183if (e) return e;
2184p -= l; len -= l; ret += l;
2185
2186*size = ret;
2187return 0;
2188}
2189
2190int ASN1CALL
2191decode_TicketFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TicketFlags *data, size_t *size)
2192{
2193size_t ret = 0;
2194size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2195int e HEIMDAL_UNUSED_ATTRIBUTE;
2196
2197memset(data, 0, sizeof(*data));
2198{
2199size_t Top_datalen, Top_oldlen;
2200Der_type Top_type;
2201e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
2202if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2203if(e) goto fail;
2204p += l; len -= l; ret += l;
2205Top_oldlen = len;
2206if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2207len = Top_datalen;
2208if (len < 1) return ASN1_OVERRUN;
2209p++; len--; ret++;
2210do {
2211if (len < 1) break;
2212(data)->reserved = (*p >> 7) & 1;
2213(data)->forwardable = (*p >> 6) & 1;
2214(data)->forwarded = (*p >> 5) & 1;
2215(data)->proxiable = (*p >> 4) & 1;
2216(data)->proxy = (*p >> 3) & 1;
2217(data)->may_postdate = (*p >> 2) & 1;
2218(data)->postdated = (*p >> 1) & 1;
2219(data)->invalid = (*p >> 0) & 1;
2220p++; len--; ret++;
2221if (len < 1) break;
2222(data)->renewable = (*p >> 7) & 1;
2223(data)->initial = (*p >> 6) & 1;
2224(data)->pre_authent = (*p >> 5) & 1;
2225(data)->hw_authent = (*p >> 4) & 1;
2226(data)->transited_policy_checked = (*p >> 3) & 1;
2227(data)->ok_as_delegate = (*p >> 2) & 1;
2228(data)->enc_pa_rep = (*p >> 0) & 1;
2229p++; len--; ret++;
2230if (len < 1) break;
2231(data)->anonymous = (*p >> 7) & 1;
2232} while(0);
2233p += len; ret += len;
2234len = Top_oldlen - Top_datalen;
2235}
2236if(size) *size = ret;
2237return 0;
2238fail:
2239free_TicketFlags(data);
2240return e;
2241}
2242
2243void ASN1CALL
2244free_TicketFlags(TicketFlags *data)
2245{
2246}
2247
2248size_t ASN1CALL
2249length_TicketFlags(const TicketFlags *data)
2250{
2251size_t ret = 0;
2252ret += 5;
2253ret += 1 + der_length_len (ret);
2254return ret;
2255}
2256
2257int ASN1CALL
2258copy_TicketFlags(const TicketFlags *from, TicketFlags *to)
2259{
2260memset(to, 0, sizeof(*to));
2261*(to) = *(from);
2262return 0;
2263}
2264
2265unsigned TicketFlags2int(TicketFlags f)
2266{
2267unsigned r = 0;
2268if(f.reserved) r |= (1U << 0);
2269if(f.forwardable) r |= (1U << 1);
2270if(f.forwarded) r |= (1U << 2);
2271if(f.proxiable) r |= (1U << 3);
2272if(f.proxy) r |= (1U << 4);
2273if(f.may_postdate) r |= (1U << 5);
2274if(f.postdated) r |= (1U << 6);
2275if(f.invalid) r |= (1U << 7);
2276if(f.renewable) r |= (1U << 8);
2277if(f.initial) r |= (1U << 9);
2278if(f.pre_authent) r |= (1U << 10);
2279if(f.hw_authent) r |= (1U << 11);
2280if(f.transited_policy_checked) r |= (1U << 12);
2281if(f.ok_as_delegate) r |= (1U << 13);
2282if(f.enc_pa_rep) r |= (1U << 15);
2283if(f.anonymous) r |= (1U << 16);
2284return r;
2285}
2286
2287TicketFlags int2TicketFlags(unsigned n)
2288{
2289 TicketFlags flags;
2290
2291 memset(&flags, 0, sizeof(flags));
2292
2293 flags.reserved = (n >> 0) & 1;
2294 flags.forwardable = (n >> 1) & 1;
2295 flags.forwarded = (n >> 2) & 1;
2296 flags.proxiable = (n >> 3) & 1;
2297 flags.proxy = (n >> 4) & 1;
2298 flags.may_postdate = (n >> 5) & 1;
2299 flags.postdated = (n >> 6) & 1;
2300 flags.invalid = (n >> 7) & 1;
2301 flags.renewable = (n >> 8) & 1;
2302 flags.initial = (n >> 9) & 1;
2303 flags.pre_authent = (n >> 10) & 1;
2304 flags.hw_authent = (n >> 11) & 1;
2305 flags.transited_policy_checked = (n >> 12) & 1;
2306 flags.ok_as_delegate = (n >> 13) & 1;
2307 flags.enc_pa_rep = (n >> 15) & 1;
2308 flags.anonymous = (n >> 16) & 1;
2309 return flags;
2310}
2311
2312static struct units TicketFlags_units[] = {
2313 {"anonymous", 1U << 16},
2314 {"enc-pa-rep", 1U << 15},
2315 {"ok-as-delegate", 1U << 13},
2316 {"transited-policy-checked", 1U << 12},
2317 {"hw-authent", 1U << 11},
2318 {"pre-authent", 1U << 10},
2319 {"initial", 1U << 9},
2320 {"renewable", 1U << 8},
2321 {"invalid", 1U << 7},
2322 {"postdated", 1U << 6},
2323 {"may-postdate", 1U << 5},
2324 {"proxy", 1U << 4},
2325 {"proxiable", 1U << 3},
2326 {"forwarded", 1U << 2},
2327 {"forwardable", 1U << 1},
2328 {"reserved", 1U << 0},
2329 {NULL, 0}
2330};
2331
2332const struct units * asn1_TicketFlags_units(void){
2333return TicketFlags_units;
2334}
2335
2336int ASN1CALL
2337encode_KDCOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDCOptions *data, size_t *size)
2338{
2339size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2340size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2341int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2342
2343{
2344unsigned char c = 0;
2345if((data)->validate) {
2346c |= 1<<0;
2347}
2348if((data)->renew) {
2349c |= 1<<1;
2350}
2351if((data)->enc_tkt_in_skey) {
2352c |= 1<<3;
2353}
2354if((data)->renewable_ok) {
2355c |= 1<<4;
2356}
2357if((data)->disable_transited_check) {
2358c |= 1<<5;
2359}
2360if (len < 1) return ASN1_OVERFLOW;
2361*p-- = c; len--; ret++;
2362c = 0;
2363if((data)->request_anonymous) {
2364c |= 1<<7;
2365}
2366if (len < 1) return ASN1_OVERFLOW;
2367*p-- = c; len--; ret++;
2368c = 0;
2369if((data)->canonicalize) {
2370c |= 1<<0;
2371}
2372if((data)->constrained_delegation) {
2373c |= 1<<1;
2374}
2375if((data)->renewable) {
2376c |= 1<<7;
2377}
2378if (len < 1) return ASN1_OVERFLOW;
2379*p-- = c; len--; ret++;
2380c = 0;
2381if((data)->postdated) {
2382c |= 1<<1;
2383}
2384if((data)->allow_postdate) {
2385c |= 1<<2;
2386}
2387if((data)->proxy) {
2388c |= 1<<3;
2389}
2390if((data)->proxiable) {
2391c |= 1<<4;
2392}
2393if((data)->forwarded) {
2394c |= 1<<5;
2395}
2396if((data)->forwardable) {
2397c |= 1<<6;
2398}
2399if((data)->reserved) {
2400c |= 1<<7;
2401}
2402if (len < 1) return ASN1_OVERFLOW;
2403*p-- = c; len--; ret++;
2404if (len < 1) return ASN1_OVERFLOW;
2405*p-- = 0;
2406len -= 1;
2407ret += 1;
2408}
2409
2410e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
2411if (e) return e;
2412p -= l; len -= l; ret += l;
2413
2414*size = ret;
2415return 0;
2416}
2417
2418int ASN1CALL
2419decode_KDCOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDCOptions *data, size_t *size)
2420{
2421size_t ret = 0;
2422size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2423int e HEIMDAL_UNUSED_ATTRIBUTE;
2424
2425memset(data, 0, sizeof(*data));
2426{
2427size_t Top_datalen, Top_oldlen;
2428Der_type Top_type;
2429e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
2430if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2431if(e) goto fail;
2432p += l; len -= l; ret += l;
2433Top_oldlen = len;
2434if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2435len = Top_datalen;
2436if (len < 1) return ASN1_OVERRUN;
2437p++; len--; ret++;
2438do {
2439if (len < 1) break;
2440(data)->reserved = (*p >> 7) & 1;
2441(data)->forwardable = (*p >> 6) & 1;
2442(data)->forwarded = (*p >> 5) & 1;
2443(data)->proxiable = (*p >> 4) & 1;
2444(data)->proxy = (*p >> 3) & 1;
2445(data)->allow_postdate = (*p >> 2) & 1;
2446(data)->postdated = (*p >> 1) & 1;
2447p++; len--; ret++;
2448if (len < 1) break;
2449(data)->renewable = (*p >> 7) & 1;
2450(data)->constrained_delegation = (*p >> 1) & 1;
2451(data)->canonicalize = (*p >> 0) & 1;
2452p++; len--; ret++;
2453if (len < 1) break;
2454(data)->request_anonymous = (*p >> 7) & 1;
2455p++; len--; ret++;
2456if (len < 1) break;
2457(data)->disable_transited_check = (*p >> 5) & 1;
2458(data)->renewable_ok = (*p >> 4) & 1;
2459(data)->enc_tkt_in_skey = (*p >> 3) & 1;
2460(data)->renew = (*p >> 1) & 1;
2461(data)->validate = (*p >> 0) & 1;
2462} while(0);
2463p += len; ret += len;
2464len = Top_oldlen - Top_datalen;
2465}
2466if(size) *size = ret;
2467return 0;
2468fail:
2469free_KDCOptions(data);
2470return e;
2471}
2472
2473void ASN1CALL
2474free_KDCOptions(KDCOptions *data)
2475{
2476}
2477
2478size_t ASN1CALL
2479length_KDCOptions(const KDCOptions *data)
2480{
2481size_t ret = 0;
2482ret += 5;
2483ret += 1 + der_length_len (ret);
2484return ret;
2485}
2486
2487int ASN1CALL
2488copy_KDCOptions(const KDCOptions *from, KDCOptions *to)
2489{
2490memset(to, 0, sizeof(*to));
2491*(to) = *(from);
2492return 0;
2493}
2494
2495unsigned KDCOptions2int(KDCOptions f)
2496{
2497unsigned r = 0;
2498if(f.reserved) r |= (1U << 0);
2499if(f.forwardable) r |= (1U << 1);
2500if(f.forwarded) r |= (1U << 2);
2501if(f.proxiable) r |= (1U << 3);
2502if(f.proxy) r |= (1U << 4);
2503if(f.allow_postdate) r |= (1U << 5);
2504if(f.postdated) r |= (1U << 6);
2505if(f.renewable) r |= (1U << 8);
2506if(f.constrained_delegation) r |= (1U << 14);
2507if(f.canonicalize) r |= (1U << 15);
2508if(f.request_anonymous) r |= (1U << 16);
2509if(f.disable_transited_check) r |= (1U << 26);
2510if(f.renewable_ok) r |= (1U << 27);
2511if(f.enc_tkt_in_skey) r |= (1U << 28);
2512if(f.renew) r |= (1U << 30);
2513if(f.validate) r |= (1U << 31);
2514return r;
2515}
2516
2517KDCOptions int2KDCOptions(unsigned n)
2518{
2519 KDCOptions flags;
2520
2521 memset(&flags, 0, sizeof(flags));
2522
2523 flags.reserved = (n >> 0) & 1;
2524 flags.forwardable = (n >> 1) & 1;
2525 flags.forwarded = (n >> 2) & 1;
2526 flags.proxiable = (n >> 3) & 1;
2527 flags.proxy = (n >> 4) & 1;
2528 flags.allow_postdate = (n >> 5) & 1;
2529 flags.postdated = (n >> 6) & 1;
2530 flags.renewable = (n >> 8) & 1;
2531 flags.constrained_delegation = (n >> 14) & 1;
2532 flags.canonicalize = (n >> 15) & 1;
2533 flags.request_anonymous = (n >> 16) & 1;
2534 flags.disable_transited_check = (n >> 26) & 1;
2535 flags.renewable_ok = (n >> 27) & 1;
2536 flags.enc_tkt_in_skey = (n >> 28) & 1;
2537 flags.renew = (n >> 30) & 1;
2538 flags.validate = (n >> 31) & 1;
2539 return flags;
2540}
2541
2542static struct units KDCOptions_units[] = {
2543 {"validate", 1U << 31},
2544 {"renew", 1U << 30},
2545 {"enc-tkt-in-skey", 1U << 28},
2546 {"renewable-ok", 1U << 27},
2547 {"disable-transited-check", 1U << 26},
2548 {"request-anonymous", 1U << 16},
2549 {"canonicalize", 1U << 15},
2550 {"constrained-delegation", 1U << 14},
2551 {"renewable", 1U << 8},
2552 {"postdated", 1U << 6},
2553 {"allow-postdate", 1U << 5},
2554 {"proxy", 1U << 4},
2555 {"proxiable", 1U << 3},
2556 {"forwarded", 1U << 2},
2557 {"forwardable", 1U << 1},
2558 {"reserved", 1U << 0},
2559 {NULL, 0}
2560};
2561
2562const struct units * asn1_KDCOptions_units(void){
2563return KDCOptions_units;
2564}
2565
2566int ASN1CALL
2567encode_LR_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const LR_TYPE *data, size_t *size)
2568{
2569size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2570size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2571int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2572
2573{
2574int enumint = (int)*data;
2575e = der_put_integer(p, len, &enumint, &l);
2576if (e) return e;
2577p -= l; len -= l; ret += l;
2578
2579}
2580;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
2581if (e) return e;
2582p -= l; len -= l; ret += l;
2583
2584*size = ret;
2585return 0;
2586}
2587
2588int ASN1CALL
2589decode_LR_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, LR_TYPE *data, size_t *size)
2590{
2591size_t ret = 0;
2592size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2593int e HEIMDAL_UNUSED_ATTRIBUTE;
2594
2595memset(data, 0, sizeof(*data));
2596{
2597size_t Top_datalen, Top_oldlen;
2598Der_type Top_type;
2599e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
2600if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
2601if(e) goto fail;
2602p += l; len -= l; ret += l;
2603Top_oldlen = len;
2604if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2605len = Top_datalen;
2606{
2607int enumint;
2608e = der_get_integer(p, len, &enumint, &l);
2609if(e) goto fail;
2610p += l; len -= l; ret += l;
2611*data = enumint;
2612}
2613len = Top_oldlen - Top_datalen;
2614}
2615if(size) *size = ret;
2616return 0;
2617fail:
2618free_LR_TYPE(data);
2619return e;
2620}
2621
2622void ASN1CALL
2623free_LR_TYPE(LR_TYPE *data)
2624{
2625}
2626
2627size_t ASN1CALL
2628length_LR_TYPE(const LR_TYPE *data)
2629{
2630size_t ret = 0;
2631{
2632int enumint = *data;
2633ret += der_length_integer(&enumint);
2634}
2635ret += 1 + der_length_len (ret);
2636return ret;
2637}
2638
2639int ASN1CALL
2640copy_LR_TYPE(const LR_TYPE *from, LR_TYPE *to)
2641{
2642memset(to, 0, sizeof(*to));
2643*(to) = *(from);
2644return 0;
2645}
2646
2647int ASN1CALL
2648encode_LastReq(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const LastReq *data, size_t *size)
2649{
2650size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2651size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2652int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2653
2654for(i = (int)(data)->len - 1; i >= 0; --i) {
2655size_t Top_tag_for_oldret = ret;
2656ret = 0;
2657/* lr-value */
2658{
2659size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2660ret = 0;
2661e = encode_KerberosTime(p, len, &(&(data)->val[i])->lr_value, &l);
2662if (e) return e;
2663p -= l; len -= l; ret += l;
2664
2665e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2666if (e) return e;
2667p -= l; len -= l; ret += l;
2668
2669ret += Top_tag_S_Of_tag_oldret;
2670}
2671/* lr-type */
2672{
2673size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2674ret = 0;
2675e = encode_LR_TYPE(p, len, &(&(data)->val[i])->lr_type, &l);
2676if (e) return e;
2677p -= l; len -= l; ret += l;
2678
2679e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2680if (e) return e;
2681p -= l; len -= l; ret += l;
2682
2683ret += Top_tag_S_Of_tag_oldret;
2684}
2685e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2686if (e) return e;
2687p -= l; len -= l; ret += l;
2688
2689ret += Top_tag_for_oldret;
2690}
2691e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2692if (e) return e;
2693p -= l; len -= l; ret += l;
2694
2695*size = ret;
2696return 0;
2697}
2698
2699int ASN1CALL
2700decode_LastReq(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, LastReq *data, size_t *size)
2701{
2702size_t ret = 0;
2703size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2704int e HEIMDAL_UNUSED_ATTRIBUTE;
2705
2706memset(data, 0, sizeof(*data));
2707{
2708size_t Top_datalen, Top_oldlen;
2709Der_type Top_type;
2710e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2711if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2712if(e) goto fail;
2713p += l; len -= l; ret += l;
2714Top_oldlen = len;
2715if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2716len = Top_datalen;
2717{
2718size_t Top_Tag_origlen = len;
2719size_t Top_Tag_oldret = ret;
2720size_t Top_Tag_olen = 0;
2721void *Top_Tag_tmp;
2722ret = 0;
2723(data)->len = 0;
2724(data)->val = NULL;
2725while(ret < Top_Tag_origlen) {
2726size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2727if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2728Top_Tag_olen = Top_Tag_nlen;
2729Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2730if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2731(data)->val = Top_Tag_tmp;
2732{
2733size_t Top_Tag_s_of_datalen, Top_Tag_s_of_oldlen;
2734Der_type Top_Tag_s_of_type;
2735e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_s_of_type, UT_Sequence, &Top_Tag_s_of_datalen, &l);
2736if (e == 0 && Top_Tag_s_of_type != CONS) { e = ASN1_BAD_ID; }
2737if(e) goto fail;
2738p += l; len -= l; ret += l;
2739Top_Tag_s_of_oldlen = len;
2740if (Top_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2741len = Top_Tag_s_of_datalen;
2742{
2743size_t lr_type_datalen, lr_type_oldlen;
2744Der_type lr_type_type;
2745e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lr_type_type, 0, &lr_type_datalen, &l);
2746if (e == 0 && lr_type_type != CONS) { e = ASN1_BAD_ID; }
2747if(e) goto fail;
2748p += l; len -= l; ret += l;
2749lr_type_oldlen = len;
2750if (lr_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2751len = lr_type_datalen;
2752e = decode_LR_TYPE(p, len, &(&(data)->val[(data)->len])->lr_type, &l);
2753if(e) goto fail;
2754p += l; len -= l; ret += l;
2755len = lr_type_oldlen - lr_type_datalen;
2756}
2757{
2758size_t lr_value_datalen, lr_value_oldlen;
2759Der_type lr_value_type;
2760e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &lr_value_type, 1, &lr_value_datalen, &l);
2761if (e == 0 && lr_value_type != CONS) { e = ASN1_BAD_ID; }
2762if(e) goto fail;
2763p += l; len -= l; ret += l;
2764lr_value_oldlen = len;
2765if (lr_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2766len = lr_value_datalen;
2767e = decode_KerberosTime(p, len, &(&(data)->val[(data)->len])->lr_value, &l);
2768if(e) goto fail;
2769p += l; len -= l; ret += l;
2770len = lr_value_oldlen - lr_value_datalen;
2771}
2772len = Top_Tag_s_of_oldlen - Top_Tag_s_of_datalen;
2773}
2774(data)->len++;
2775len = Top_Tag_origlen - ret;
2776}
2777ret += Top_Tag_oldret;
2778}
2779len = Top_oldlen - Top_datalen;
2780}
2781if(size) *size = ret;
2782return 0;
2783fail:
2784free_LastReq(data);
2785return e;
2786}
2787
2788void ASN1CALL
2789free_LastReq(LastReq *data)
2790{
2791while((data)->len){
2792free_LR_TYPE(&(&(data)->val[(data)->len-1])->lr_type);
2793free_KerberosTime(&(&(data)->val[(data)->len-1])->lr_value);
2794(data)->len--;
2795}
2796free((data)->val);
2797(data)->val = NULL;
2798}
2799
2800size_t ASN1CALL
2801length_LastReq(const LastReq *data)
2802{
2803size_t ret = 0;
2804{
2805size_t Top_tag_oldret = ret;
2806unsigned int n_Top_tag;
2807ret = 0;
2808for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
2809size_t Top_tag_for_oldret = ret;
2810ret = 0;
2811{
2812size_t Top_tag_S_Of_tag_oldret = ret;
2813ret = 0;
2814ret += length_LR_TYPE(&(&(data)->val[n_Top_tag - 1])->lr_type);
2815ret += 1 + der_length_len (ret);
2816ret += Top_tag_S_Of_tag_oldret;
2817}
2818{
2819size_t Top_tag_S_Of_tag_oldret = ret;
2820ret = 0;
2821ret += length_KerberosTime(&(&(data)->val[n_Top_tag - 1])->lr_value);
2822ret += 1 + der_length_len (ret);
2823ret += Top_tag_S_Of_tag_oldret;
2824}
2825ret += 1 + der_length_len (ret);
2826ret += Top_tag_for_oldret;
2827}
2828ret += Top_tag_oldret;
2829}
2830ret += 1 + der_length_len (ret);
2831return ret;
2832}
2833
2834int ASN1CALL
2835copy_LastReq(const LastReq *from, LastReq *to)
2836{
2837memset(to, 0, sizeof(*to));
2838if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
2839goto fail;
2840for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
2841if(copy_LR_TYPE(&(&(from)->val[(to)->len])->lr_type, &(&(to)->val[(to)->len])->lr_type)) goto fail;
2842if(copy_KerberosTime(&(&(from)->val[(to)->len])->lr_value, &(&(to)->val[(to)->len])->lr_value)) goto fail;
2843}
2844return 0;
2845fail:
2846free_LastReq(to);
2847return ENOMEM;
2848}
2849
2850int ASN1CALL
2851encode_EncryptedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncryptedData *data, size_t *size)
2852{
2853size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2854size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2855int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2856
2857/* cipher */
2858{
2859size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2860ret = 0;
2861e = der_put_octet_string(p, len, &(data)->cipher, &l);
2862if (e) return e;
2863p -= l; len -= l; ret += l;
2864
2865e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
2866if (e) return e;
2867p -= l; len -= l; ret += l;
2868
2869e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
2870if (e) return e;
2871p -= l; len -= l; ret += l;
2872
2873ret += Top_tag_oldret;
2874}
2875/* kvno */
2876if((data)->kvno) {
2877size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2878ret = 0;
2879e = encode_krb5int32(p, len, (data)->kvno, &l);
2880if (e) return e;
2881p -= l; len -= l; ret += l;
2882
2883e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2884if (e) return e;
2885p -= l; len -= l; ret += l;
2886
2887ret += Top_tag_oldret;
2888}
2889/* etype */
2890{
2891size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2892ret = 0;
2893e = encode_ENCTYPE(p, len, &(data)->etype, &l);
2894if (e) return e;
2895p -= l; len -= l; ret += l;
2896
2897e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2898if (e) return e;
2899p -= l; len -= l; ret += l;
2900
2901ret += Top_tag_oldret;
2902}
2903e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2904if (e) return e;
2905p -= l; len -= l; ret += l;
2906
2907*size = ret;
2908return 0;
2909}
2910
2911int ASN1CALL
2912decode_EncryptedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncryptedData *data, size_t *size)
2913{
2914size_t ret = 0;
2915size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2916int e HEIMDAL_UNUSED_ATTRIBUTE;
2917
2918memset(data, 0, sizeof(*data));
2919{
2920size_t Top_datalen, Top_oldlen;
2921Der_type Top_type;
2922e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2923if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2924if(e) goto fail;
2925p += l; len -= l; ret += l;
2926Top_oldlen = len;
2927if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2928len = Top_datalen;
2929{
2930size_t etype_datalen, etype_oldlen;
2931Der_type etype_type;
2932e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
2933if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
2934if(e) goto fail;
2935p += l; len -= l; ret += l;
2936etype_oldlen = len;
2937if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2938len = etype_datalen;
2939e = decode_ENCTYPE(p, len, &(data)->etype, &l);
2940if(e) goto fail;
2941p += l; len -= l; ret += l;
2942len = etype_oldlen - etype_datalen;
2943}
2944{
2945size_t kvno_datalen, kvno_oldlen;
2946Der_type kvno_type;
2947e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kvno_type, 1, &kvno_datalen, &l);
2948if (e == 0 && kvno_type != CONS) { e = ASN1_BAD_ID; }
2949if(e) {
2950(data)->kvno = NULL;
2951} else {
2952(data)->kvno = calloc(1, sizeof(*(data)->kvno));
2953if ((data)->kvno == NULL) { e = ENOMEM; goto fail; }
2954p += l; len -= l; ret += l;
2955kvno_oldlen = len;
2956if (kvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2957len = kvno_datalen;
2958e = decode_krb5int32(p, len, (data)->kvno, &l);
2959if(e) goto fail;
2960p += l; len -= l; ret += l;
2961len = kvno_oldlen - kvno_datalen;
2962}
2963}
2964{
2965size_t cipher_datalen, cipher_oldlen;
2966Der_type cipher_type;
2967e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cipher_type, 2, &cipher_datalen, &l);
2968if (e == 0 && cipher_type != CONS) { e = ASN1_BAD_ID; }
2969if(e) goto fail;
2970p += l; len -= l; ret += l;
2971cipher_oldlen = len;
2972if (cipher_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2973len = cipher_datalen;
2974{
2975size_t cipher_Tag_datalen, cipher_Tag_oldlen;
2976Der_type cipher_Tag_type;
2977e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cipher_Tag_type, UT_OctetString, &cipher_Tag_datalen, &l);
2978if (e == 0 && cipher_Tag_type != PRIM) { e = ASN1_BAD_ID; }
2979if(e) goto fail;
2980p += l; len -= l; ret += l;
2981cipher_Tag_oldlen = len;
2982if (cipher_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
2983len = cipher_Tag_datalen;
2984e = der_get_octet_string(p, len, &(data)->cipher, &l);
2985if(e) goto fail;
2986p += l; len -= l; ret += l;
2987len = cipher_Tag_oldlen - cipher_Tag_datalen;
2988}
2989len = cipher_oldlen - cipher_datalen;
2990}
2991len = Top_oldlen - Top_datalen;
2992}
2993if(size) *size = ret;
2994return 0;
2995fail:
2996free_EncryptedData(data);
2997return e;
2998}
2999
3000void ASN1CALL
3001free_EncryptedData(EncryptedData *data)
3002{
3003free_ENCTYPE(&(data)->etype);
3004if((data)->kvno) {
3005free_krb5int32((data)->kvno);
3006free((data)->kvno);
3007(data)->kvno = NULL;
3008}
3009der_free_octet_string(&(data)->cipher);
3010}
3011
3012size_t ASN1CALL
3013length_EncryptedData(const EncryptedData *data)
3014{
3015size_t ret = 0;
3016{
3017size_t Top_tag_oldret = ret;
3018ret = 0;
3019ret += length_ENCTYPE(&(data)->etype);
3020ret += 1 + der_length_len (ret);
3021ret += Top_tag_oldret;
3022}
3023if((data)->kvno){
3024size_t Top_tag_oldret = ret;
3025ret = 0;
3026ret += length_krb5int32((data)->kvno);
3027ret += 1 + der_length_len (ret);
3028ret += Top_tag_oldret;
3029}
3030{
3031size_t Top_tag_oldret = ret;
3032ret = 0;
3033ret += der_length_octet_string(&(data)->cipher);
3034ret += 1 + der_length_len (ret);
3035ret += 1 + der_length_len (ret);
3036ret += Top_tag_oldret;
3037}
3038ret += 1 + der_length_len (ret);
3039return ret;
3040}
3041
3042int ASN1CALL
3043copy_EncryptedData(const EncryptedData *from, EncryptedData *to)
3044{
3045memset(to, 0, sizeof(*to));
3046if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
3047if((from)->kvno) {
3048(to)->kvno = malloc(sizeof(*(to)->kvno));
3049if((to)->kvno == NULL) goto fail;
3050if(copy_krb5int32((from)->kvno, (to)->kvno)) goto fail;
3051}else
3052(to)->kvno = NULL;
3053if(der_copy_octet_string(&(from)->cipher, &(to)->cipher)) goto fail;
3054return 0;
3055fail:
3056free_EncryptedData(to);
3057return ENOMEM;
3058}
3059
3060int ASN1CALL
3061encode_EncryptionKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncryptionKey *data, size_t *size)
3062{
3063size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3064size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3065int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3066
3067/* keyvalue */
3068{
3069size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3070ret = 0;
3071e = der_put_octet_string(p, len, &(data)->keyvalue, &l);
3072if (e) return e;
3073p -= l; len -= l; ret += l;
3074
3075e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3076if (e) return e;
3077p -= l; len -= l; ret += l;
3078
3079e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3080if (e) return e;
3081p -= l; len -= l; ret += l;
3082
3083ret += Top_tag_oldret;
3084}
3085/* keytype */
3086{
3087size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3088ret = 0;
3089e = encode_krb5int32(p, len, &(data)->keytype, &l);
3090if (e) return e;
3091p -= l; len -= l; ret += l;
3092
3093e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3094if (e) return e;
3095p -= l; len -= l; ret += l;
3096
3097ret += Top_tag_oldret;
3098}
3099e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3100if (e) return e;
3101p -= l; len -= l; ret += l;
3102
3103*size = ret;
3104return 0;
3105}
3106
3107int ASN1CALL
3108decode_EncryptionKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncryptionKey *data, size_t *size)
3109{
3110size_t ret = 0;
3111size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3112int e HEIMDAL_UNUSED_ATTRIBUTE;
3113
3114memset(data, 0, sizeof(*data));
3115{
3116size_t Top_datalen, Top_oldlen;
3117Der_type Top_type;
3118e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3119if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3120if(e) goto fail;
3121p += l; len -= l; ret += l;
3122Top_oldlen = len;
3123if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3124len = Top_datalen;
3125{
3126size_t keytype_datalen, keytype_oldlen;
3127Der_type keytype_type;
3128e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keytype_type, 0, &keytype_datalen, &l);
3129if (e == 0 && keytype_type != CONS) { e = ASN1_BAD_ID; }
3130if(e) goto fail;
3131p += l; len -= l; ret += l;
3132keytype_oldlen = len;
3133if (keytype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3134len = keytype_datalen;
3135e = decode_krb5int32(p, len, &(data)->keytype, &l);
3136if(e) goto fail;
3137p += l; len -= l; ret += l;
3138len = keytype_oldlen - keytype_datalen;
3139}
3140{
3141size_t keyvalue_datalen, keyvalue_oldlen;
3142Der_type keyvalue_type;
3143e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keyvalue_type, 1, &keyvalue_datalen, &l);
3144if (e == 0 && keyvalue_type != CONS) { e = ASN1_BAD_ID; }
3145if(e) goto fail;
3146p += l; len -= l; ret += l;
3147keyvalue_oldlen = len;
3148if (keyvalue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3149len = keyvalue_datalen;
3150{
3151size_t keyvalue_Tag_datalen, keyvalue_Tag_oldlen;
3152Der_type keyvalue_Tag_type;
3153e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &keyvalue_Tag_type, UT_OctetString, &keyvalue_Tag_datalen, &l);
3154if (e == 0 && keyvalue_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3155if(e) goto fail;
3156p += l; len -= l; ret += l;
3157keyvalue_Tag_oldlen = len;
3158if (keyvalue_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3159len = keyvalue_Tag_datalen;
3160e = der_get_octet_string(p, len, &(data)->keyvalue, &l);
3161if(e) goto fail;
3162p += l; len -= l; ret += l;
3163len = keyvalue_Tag_oldlen - keyvalue_Tag_datalen;
3164}
3165len = keyvalue_oldlen - keyvalue_datalen;
3166}
3167len = Top_oldlen - Top_datalen;
3168}
3169if(size) *size = ret;
3170return 0;
3171fail:
3172free_EncryptionKey(data);
3173return e;
3174}
3175
3176void ASN1CALL
3177free_EncryptionKey(EncryptionKey *data)
3178{
3179free_krb5int32(&(data)->keytype);
3180der_free_octet_string(&(data)->keyvalue);
3181}
3182
3183size_t ASN1CALL
3184length_EncryptionKey(const EncryptionKey *data)
3185{
3186size_t ret = 0;
3187{
3188size_t Top_tag_oldret = ret;
3189ret = 0;
3190ret += length_krb5int32(&(data)->keytype);
3191ret += 1 + der_length_len (ret);
3192ret += Top_tag_oldret;
3193}
3194{
3195size_t Top_tag_oldret = ret;
3196ret = 0;
3197ret += der_length_octet_string(&(data)->keyvalue);
3198ret += 1 + der_length_len (ret);
3199ret += 1 + der_length_len (ret);
3200ret += Top_tag_oldret;
3201}
3202ret += 1 + der_length_len (ret);
3203return ret;
3204}
3205
3206int ASN1CALL
3207copy_EncryptionKey(const EncryptionKey *from, EncryptionKey *to)
3208{
3209memset(to, 0, sizeof(*to));
3210if(copy_krb5int32(&(from)->keytype, &(to)->keytype)) goto fail;
3211if(der_copy_octet_string(&(from)->keyvalue, &(to)->keyvalue)) goto fail;
3212return 0;
3213fail:
3214free_EncryptionKey(to);
3215return ENOMEM;
3216}
3217
3218int ASN1CALL
3219encode_TransitedEncoding(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TransitedEncoding *data, size_t *size)
3220{
3221size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3222size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3223int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3224
3225/* contents */
3226{
3227size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3228ret = 0;
3229e = der_put_octet_string(p, len, &(data)->contents, &l);
3230if (e) return e;
3231p -= l; len -= l; ret += l;
3232
3233e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3234if (e) return e;
3235p -= l; len -= l; ret += l;
3236
3237e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3238if (e) return e;
3239p -= l; len -= l; ret += l;
3240
3241ret += Top_tag_oldret;
3242}
3243/* tr-type */
3244{
3245size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3246ret = 0;
3247e = encode_krb5int32(p, len, &(data)->tr_type, &l);
3248if (e) return e;
3249p -= l; len -= l; ret += l;
3250
3251e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3252if (e) return e;
3253p -= l; len -= l; ret += l;
3254
3255ret += Top_tag_oldret;
3256}
3257e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3258if (e) return e;
3259p -= l; len -= l; ret += l;
3260
3261*size = ret;
3262return 0;
3263}
3264
3265int ASN1CALL
3266decode_TransitedEncoding(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TransitedEncoding *data, size_t *size)
3267{
3268size_t ret = 0;
3269size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3270int e HEIMDAL_UNUSED_ATTRIBUTE;
3271
3272memset(data, 0, sizeof(*data));
3273{
3274size_t Top_datalen, Top_oldlen;
3275Der_type Top_type;
3276e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3277if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3278if(e) goto fail;
3279p += l; len -= l; ret += l;
3280Top_oldlen = len;
3281if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3282len = Top_datalen;
3283{
3284size_t tr_type_datalen, tr_type_oldlen;
3285Der_type tr_type_type;
3286e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tr_type_type, 0, &tr_type_datalen, &l);
3287if (e == 0 && tr_type_type != CONS) { e = ASN1_BAD_ID; }
3288if(e) goto fail;
3289p += l; len -= l; ret += l;
3290tr_type_oldlen = len;
3291if (tr_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3292len = tr_type_datalen;
3293e = decode_krb5int32(p, len, &(data)->tr_type, &l);
3294if(e) goto fail;
3295p += l; len -= l; ret += l;
3296len = tr_type_oldlen - tr_type_datalen;
3297}
3298{
3299size_t contents_datalen, contents_oldlen;
3300Der_type contents_type;
3301e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &contents_type, 1, &contents_datalen, &l);
3302if (e == 0 && contents_type != CONS) { e = ASN1_BAD_ID; }
3303if(e) goto fail;
3304p += l; len -= l; ret += l;
3305contents_oldlen = len;
3306if (contents_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3307len = contents_datalen;
3308{
3309size_t contents_Tag_datalen, contents_Tag_oldlen;
3310Der_type contents_Tag_type;
3311e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &contents_Tag_type, UT_OctetString, &contents_Tag_datalen, &l);
3312if (e == 0 && contents_Tag_type != PRIM) { e = ASN1_BAD_ID; }
3313if(e) goto fail;
3314p += l; len -= l; ret += l;
3315contents_Tag_oldlen = len;
3316if (contents_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3317len = contents_Tag_datalen;
3318e = der_get_octet_string(p, len, &(data)->contents, &l);
3319if(e) goto fail;
3320p += l; len -= l; ret += l;
3321len = contents_Tag_oldlen - contents_Tag_datalen;
3322}
3323len = contents_oldlen - contents_datalen;
3324}
3325len = Top_oldlen - Top_datalen;
3326}
3327if(size) *size = ret;
3328return 0;
3329fail:
3330free_TransitedEncoding(data);
3331return e;
3332}
3333
3334void ASN1CALL
3335free_TransitedEncoding(TransitedEncoding *data)
3336{
3337free_krb5int32(&(data)->tr_type);
3338der_free_octet_string(&(data)->contents);
3339}
3340
3341size_t ASN1CALL
3342length_TransitedEncoding(const TransitedEncoding *data)
3343{
3344size_t ret = 0;
3345{
3346size_t Top_tag_oldret = ret;
3347ret = 0;
3348ret += length_krb5int32(&(data)->tr_type);
3349ret += 1 + der_length_len (ret);
3350ret += Top_tag_oldret;
3351}
3352{
3353size_t Top_tag_oldret = ret;
3354ret = 0;
3355ret += der_length_octet_string(&(data)->contents);
3356ret += 1 + der_length_len (ret);
3357ret += 1 + der_length_len (ret);
3358ret += Top_tag_oldret;
3359}
3360ret += 1 + der_length_len (ret);
3361return ret;
3362}
3363
3364int ASN1CALL
3365copy_TransitedEncoding(const TransitedEncoding *from, TransitedEncoding *to)
3366{
3367memset(to, 0, sizeof(*to));
3368if(copy_krb5int32(&(from)->tr_type, &(to)->tr_type)) goto fail;
3369if(der_copy_octet_string(&(from)->contents, &(to)->contents)) goto fail;
3370return 0;
3371fail:
3372free_TransitedEncoding(to);
3373return ENOMEM;
3374}
3375
3376int ASN1CALL
3377encode_Ticket(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Ticket *data, size_t *size)
3378{
3379size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3380size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3381int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3382
3383/* enc-part */
3384{
3385size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3386ret = 0;
3387e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
3388if (e) return e;
3389p -= l; len -= l; ret += l;
3390
3391e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
3392if (e) return e;
3393p -= l; len -= l; ret += l;
3394
3395ret += Top_tag_tag_oldret;
3396}
3397/* sname */
3398{
3399size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3400ret = 0;
3401e = encode_PrincipalName(p, len, &(data)->sname, &l);
3402if (e) return e;
3403p -= l; len -= l; ret += l;
3404
3405e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3406if (e) return e;
3407p -= l; len -= l; ret += l;
3408
3409ret += Top_tag_tag_oldret;
3410}
3411/* realm */
3412{
3413size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3414ret = 0;
3415e = encode_Realm(p, len, &(data)->realm, &l);
3416if (e) return e;
3417p -= l; len -= l; ret += l;
3418
3419e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3420if (e) return e;
3421p -= l; len -= l; ret += l;
3422
3423ret += Top_tag_tag_oldret;
3424}
3425/* tkt-vno */
3426{
3427size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3428ret = 0;
3429e = encode_krb5int32(p, len, &(data)->tkt_vno, &l);
3430if (e) return e;
3431p -= l; len -= l; ret += l;
3432
3433e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3434if (e) return e;
3435p -= l; len -= l; ret += l;
3436
3437ret += Top_tag_tag_oldret;
3438}
3439e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3440if (e) return e;
3441p -= l; len -= l; ret += l;
3442
3443e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 1, &l);
3444if (e) return e;
3445p -= l; len -= l; ret += l;
3446
3447*size = ret;
3448return 0;
3449}
3450
3451int ASN1CALL
3452decode_Ticket(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Ticket *data, size_t *size)
3453{
3454size_t ret = 0;
3455size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3456int e HEIMDAL_UNUSED_ATTRIBUTE;
3457
3458memset(data, 0, sizeof(*data));
3459{
3460size_t Top_datalen, Top_oldlen;
3461Der_type Top_type;
3462e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 1, &Top_datalen, &l);
3463if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3464if(e) goto fail;
3465p += l; len -= l; ret += l;
3466Top_oldlen = len;
3467if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3468len = Top_datalen;
3469{
3470size_t Top_Tag_datalen, Top_Tag_oldlen;
3471Der_type Top_Tag_type;
3472e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
3473if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
3474if(e) goto fail;
3475p += l; len -= l; ret += l;
3476Top_Tag_oldlen = len;
3477if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3478len = Top_Tag_datalen;
3479{
3480size_t tkt_vno_datalen, tkt_vno_oldlen;
3481Der_type tkt_vno_type;
3482e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tkt_vno_type, 0, &tkt_vno_datalen, &l);
3483if (e == 0 && tkt_vno_type != CONS) { e = ASN1_BAD_ID; }
3484if(e) goto fail;
3485p += l; len -= l; ret += l;
3486tkt_vno_oldlen = len;
3487if (tkt_vno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3488len = tkt_vno_datalen;
3489e = decode_krb5int32(p, len, &(data)->tkt_vno, &l);
3490if(e) goto fail;
3491p += l; len -= l; ret += l;
3492len = tkt_vno_oldlen - tkt_vno_datalen;
3493}
3494{
3495size_t realm_datalen, realm_oldlen;
3496Der_type realm_type;
3497e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 1, &realm_datalen, &l);
3498if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
3499if(e) goto fail;
3500p += l; len -= l; ret += l;
3501realm_oldlen = len;
3502if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3503len = realm_datalen;
3504e = decode_Realm(p, len, &(data)->realm, &l);
3505if(e) goto fail;
3506p += l; len -= l; ret += l;
3507len = realm_oldlen - realm_datalen;
3508}
3509{
3510size_t sname_datalen, sname_oldlen;
3511Der_type sname_type;
3512e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 2, &sname_datalen, &l);
3513if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
3514if(e) goto fail;
3515p += l; len -= l; ret += l;
3516sname_oldlen = len;
3517if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3518len = sname_datalen;
3519e = decode_PrincipalName(p, len, &(data)->sname, &l);
3520if(e) goto fail;
3521p += l; len -= l; ret += l;
3522len = sname_oldlen - sname_datalen;
3523}
3524{
3525size_t enc_part_datalen, enc_part_oldlen;
3526Der_type enc_part_type;
3527e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 3, &enc_part_datalen, &l);
3528if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
3529if(e) goto fail;
3530p += l; len -= l; ret += l;
3531enc_part_oldlen = len;
3532if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3533len = enc_part_datalen;
3534e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
3535if(e) goto fail;
3536p += l; len -= l; ret += l;
3537len = enc_part_oldlen - enc_part_datalen;
3538}
3539len = Top_Tag_oldlen - Top_Tag_datalen;
3540}
3541len = Top_oldlen - Top_datalen;
3542}
3543if(size) *size = ret;
3544return 0;
3545fail:
3546free_Ticket(data);
3547return e;
3548}
3549
3550void ASN1CALL
3551free_Ticket(Ticket *data)
3552{
3553free_krb5int32(&(data)->tkt_vno);
3554free_Realm(&(data)->realm);
3555free_PrincipalName(&(data)->sname);
3556free_EncryptedData(&(data)->enc_part);
3557}
3558
3559size_t ASN1CALL
3560length_Ticket(const Ticket *data)
3561{
3562size_t ret = 0;
3563{
3564size_t Top_tag_tag_oldret = ret;
3565ret = 0;
3566ret += length_krb5int32(&(data)->tkt_vno);
3567ret += 1 + der_length_len (ret);
3568ret += Top_tag_tag_oldret;
3569}
3570{
3571size_t Top_tag_tag_oldret = ret;
3572ret = 0;
3573ret += length_Realm(&(data)->realm);
3574ret += 1 + der_length_len (ret);
3575ret += Top_tag_tag_oldret;
3576}
3577{
3578size_t Top_tag_tag_oldret = ret;
3579ret = 0;
3580ret += length_PrincipalName(&(data)->sname);
3581ret += 1 + der_length_len (ret);
3582ret += Top_tag_tag_oldret;
3583}
3584{
3585size_t Top_tag_tag_oldret = ret;
3586ret = 0;
3587ret += length_EncryptedData(&(data)->enc_part);
3588ret += 1 + der_length_len (ret);
3589ret += Top_tag_tag_oldret;
3590}
3591ret += 1 + der_length_len (ret);
3592ret += 1 + der_length_len (ret);
3593return ret;
3594}
3595
3596int ASN1CALL
3597copy_Ticket(const Ticket *from, Ticket *to)
3598{
3599memset(to, 0, sizeof(*to));
3600if(copy_krb5int32(&(from)->tkt_vno, &(to)->tkt_vno)) goto fail;
3601if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
3602if(copy_PrincipalName(&(from)->sname, &(to)->sname)) goto fail;
3603if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
3604return 0;
3605fail:
3606free_Ticket(to);
3607return ENOMEM;
3608}
3609
3610int ASN1CALL
3611encode_EncTicketPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncTicketPart *data, size_t *size)
3612{
3613size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3614size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3615int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3616
3617/* authorization-data */
3618if((data)->authorization_data) {
3619size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3620ret = 0;
3621e = encode_AuthorizationData(p, len, (data)->authorization_data, &l);
3622if (e) return e;
3623p -= l; len -= l; ret += l;
3624
3625e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
3626if (e) return e;
3627p -= l; len -= l; ret += l;
3628
3629ret += Top_tag_tag_oldret;
3630}
3631/* caddr */
3632if((data)->caddr) {
3633size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3634ret = 0;
3635e = encode_HostAddresses(p, len, (data)->caddr, &l);
3636if (e) return e;
3637p -= l; len -= l; ret += l;
3638
3639e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
3640if (e) return e;
3641p -= l; len -= l; ret += l;
3642
3643ret += Top_tag_tag_oldret;
3644}
3645/* renew-till */
3646if((data)->renew_till) {
3647size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3648ret = 0;
3649e = encode_KerberosTime(p, len, (data)->renew_till, &l);
3650if (e) return e;
3651p -= l; len -= l; ret += l;
3652
3653e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
3654if (e) return e;
3655p -= l; len -= l; ret += l;
3656
3657ret += Top_tag_tag_oldret;
3658}
3659/* endtime */
3660{
3661size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3662ret = 0;
3663e = encode_KerberosTime(p, len, &(data)->endtime, &l);
3664if (e) return e;
3665p -= l; len -= l; ret += l;
3666
3667e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
3668if (e) return e;
3669p -= l; len -= l; ret += l;
3670
3671ret += Top_tag_tag_oldret;
3672}
3673/* starttime */
3674if((data)->starttime) {
3675size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3676ret = 0;
3677e = encode_KerberosTime(p, len, (data)->starttime, &l);
3678if (e) return e;
3679p -= l; len -= l; ret += l;
3680
3681e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
3682if (e) return e;
3683p -= l; len -= l; ret += l;
3684
3685ret += Top_tag_tag_oldret;
3686}
3687/* authtime */
3688{
3689size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3690ret = 0;
3691e = encode_KerberosTime(p, len, &(data)->authtime, &l);
3692if (e) return e;
3693p -= l; len -= l; ret += l;
3694
3695e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
3696if (e) return e;
3697p -= l; len -= l; ret += l;
3698
3699ret += Top_tag_tag_oldret;
3700}
3701/* transited */
3702{
3703size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3704ret = 0;
3705e = encode_TransitedEncoding(p, len, &(data)->transited, &l);
3706if (e) return e;
3707p -= l; len -= l; ret += l;
3708
3709e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
3710if (e) return e;
3711p -= l; len -= l; ret += l;
3712
3713ret += Top_tag_tag_oldret;
3714}
3715/* cname */
3716{
3717size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3718ret = 0;
3719e = encode_PrincipalName(p, len, &(data)->cname, &l);
3720if (e) return e;
3721p -= l; len -= l; ret += l;
3722
3723e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
3724if (e) return e;
3725p -= l; len -= l; ret += l;
3726
3727ret += Top_tag_tag_oldret;
3728}
3729/* crealm */
3730{
3731size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3732ret = 0;
3733e = encode_Realm(p, len, &(data)->crealm, &l);
3734if (e) return e;
3735p -= l; len -= l; ret += l;
3736
3737e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
3738if (e) return e;
3739p -= l; len -= l; ret += l;
3740
3741ret += Top_tag_tag_oldret;
3742}
3743/* key */
3744{
3745size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3746ret = 0;
3747e = encode_EncryptionKey(p, len, &(data)->key, &l);
3748if (e) return e;
3749p -= l; len -= l; ret += l;
3750
3751e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
3752if (e) return e;
3753p -= l; len -= l; ret += l;
3754
3755ret += Top_tag_tag_oldret;
3756}
3757/* flags */
3758{
3759size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3760ret = 0;
3761e = encode_TicketFlags(p, len, &(data)->flags, &l);
3762if (e) return e;
3763p -= l; len -= l; ret += l;
3764
3765e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
3766if (e) return e;
3767p -= l; len -= l; ret += l;
3768
3769ret += Top_tag_tag_oldret;
3770}
3771e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3772if (e) return e;
3773p -= l; len -= l; ret += l;
3774
3775e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 3, &l);
3776if (e) return e;
3777p -= l; len -= l; ret += l;
3778
3779*size = ret;
3780return 0;
3781}
3782
3783int ASN1CALL
3784decode_EncTicketPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncTicketPart *data, size_t *size)
3785{
3786size_t ret = 0;
3787size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3788int e HEIMDAL_UNUSED_ATTRIBUTE;
3789
3790memset(data, 0, sizeof(*data));
3791{
3792size_t Top_datalen, Top_oldlen;
3793Der_type Top_type;
3794e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 3, &Top_datalen, &l);
3795if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3796if(e) goto fail;
3797p += l; len -= l; ret += l;
3798Top_oldlen = len;
3799if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3800len = Top_datalen;
3801{
3802size_t Top_Tag_datalen, Top_Tag_oldlen;
3803Der_type Top_Tag_type;
3804e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
3805if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
3806if(e) goto fail;
3807p += l; len -= l; ret += l;
3808Top_Tag_oldlen = len;
3809if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3810len = Top_Tag_datalen;
3811{
3812size_t flags_datalen, flags_oldlen;
3813Der_type flags_type;
3814e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 0, &flags_datalen, &l);
3815if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
3816if(e) goto fail;
3817p += l; len -= l; ret += l;
3818flags_oldlen = len;
3819if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3820len = flags_datalen;
3821e = decode_TicketFlags(p, len, &(data)->flags, &l);
3822if(e) goto fail;
3823p += l; len -= l; ret += l;
3824len = flags_oldlen - flags_datalen;
3825}
3826{
3827size_t key_datalen, key_oldlen;
3828Der_type key_type;
3829e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 1, &key_datalen, &l);
3830if (e == 0 && key_type != CONS) { e = ASN1_BAD_ID; }
3831if(e) goto fail;
3832p += l; len -= l; ret += l;
3833key_oldlen = len;
3834if (key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3835len = key_datalen;
3836e = decode_EncryptionKey(p, len, &(data)->key, &l);
3837if(e) goto fail;
3838p += l; len -= l; ret += l;
3839len = key_oldlen - key_datalen;
3840}
3841{
3842size_t crealm_datalen, crealm_oldlen;
3843Der_type crealm_type;
3844e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 2, &crealm_datalen, &l);
3845if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
3846if(e) goto fail;
3847p += l; len -= l; ret += l;
3848crealm_oldlen = len;
3849if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3850len = crealm_datalen;
3851e = decode_Realm(p, len, &(data)->crealm, &l);
3852if(e) goto fail;
3853p += l; len -= l; ret += l;
3854len = crealm_oldlen - crealm_datalen;
3855}
3856{
3857size_t cname_datalen, cname_oldlen;
3858Der_type cname_type;
3859e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 3, &cname_datalen, &l);
3860if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
3861if(e) goto fail;
3862p += l; len -= l; ret += l;
3863cname_oldlen = len;
3864if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3865len = cname_datalen;
3866e = decode_PrincipalName(p, len, &(data)->cname, &l);
3867if(e) goto fail;
3868p += l; len -= l; ret += l;
3869len = cname_oldlen - cname_datalen;
3870}
3871{
3872size_t transited_datalen, transited_oldlen;
3873Der_type transited_type;
3874e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &transited_type, 4, &transited_datalen, &l);
3875if (e == 0 && transited_type != CONS) { e = ASN1_BAD_ID; }
3876if(e) goto fail;
3877p += l; len -= l; ret += l;
3878transited_oldlen = len;
3879if (transited_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3880len = transited_datalen;
3881e = decode_TransitedEncoding(p, len, &(data)->transited, &l);
3882if(e) goto fail;
3883p += l; len -= l; ret += l;
3884len = transited_oldlen - transited_datalen;
3885}
3886{
3887size_t authtime_datalen, authtime_oldlen;
3888Der_type authtime_type;
3889e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 5, &authtime_datalen, &l);
3890if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
3891if(e) goto fail;
3892p += l; len -= l; ret += l;
3893authtime_oldlen = len;
3894if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3895len = authtime_datalen;
3896e = decode_KerberosTime(p, len, &(data)->authtime, &l);
3897if(e) goto fail;
3898p += l; len -= l; ret += l;
3899len = authtime_oldlen - authtime_datalen;
3900}
3901{
3902size_t starttime_datalen, starttime_oldlen;
3903Der_type starttime_type;
3904e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 6, &starttime_datalen, &l);
3905if (e == 0 && starttime_type != CONS) { e = ASN1_BAD_ID; }
3906if(e) {
3907(data)->starttime = NULL;
3908} else {
3909(data)->starttime = calloc(1, sizeof(*(data)->starttime));
3910if ((data)->starttime == NULL) { e = ENOMEM; goto fail; }
3911p += l; len -= l; ret += l;
3912starttime_oldlen = len;
3913if (starttime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3914len = starttime_datalen;
3915e = decode_KerberosTime(p, len, (data)->starttime, &l);
3916if(e) goto fail;
3917p += l; len -= l; ret += l;
3918len = starttime_oldlen - starttime_datalen;
3919}
3920}
3921{
3922size_t endtime_datalen, endtime_oldlen;
3923Der_type endtime_type;
3924e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 7, &endtime_datalen, &l);
3925if (e == 0 && endtime_type != CONS) { e = ASN1_BAD_ID; }
3926if(e) goto fail;
3927p += l; len -= l; ret += l;
3928endtime_oldlen = len;
3929if (endtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3930len = endtime_datalen;
3931e = decode_KerberosTime(p, len, &(data)->endtime, &l);
3932if(e) goto fail;
3933p += l; len -= l; ret += l;
3934len = endtime_oldlen - endtime_datalen;
3935}
3936{
3937size_t renew_till_datalen, renew_till_oldlen;
3938Der_type renew_till_type;
3939e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 8, &renew_till_datalen, &l);
3940if (e == 0 && renew_till_type != CONS) { e = ASN1_BAD_ID; }
3941if(e) {
3942(data)->renew_till = NULL;
3943} else {
3944(data)->renew_till = calloc(1, sizeof(*(data)->renew_till));
3945if ((data)->renew_till == NULL) { e = ENOMEM; goto fail; }
3946p += l; len -= l; ret += l;
3947renew_till_oldlen = len;
3948if (renew_till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3949len = renew_till_datalen;
3950e = decode_KerberosTime(p, len, (data)->renew_till, &l);
3951if(e) goto fail;
3952p += l; len -= l; ret += l;
3953len = renew_till_oldlen - renew_till_datalen;
3954}
3955}
3956{
3957size_t caddr_datalen, caddr_oldlen;
3958Der_type caddr_type;
3959e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &caddr_type, 9, &caddr_datalen, &l);
3960if (e == 0 && caddr_type != CONS) { e = ASN1_BAD_ID; }
3961if(e) {
3962(data)->caddr = NULL;
3963} else {
3964(data)->caddr = calloc(1, sizeof(*(data)->caddr));
3965if ((data)->caddr == NULL) { e = ENOMEM; goto fail; }
3966p += l; len -= l; ret += l;
3967caddr_oldlen = len;
3968if (caddr_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3969len = caddr_datalen;
3970e = decode_HostAddresses(p, len, (data)->caddr, &l);
3971if(e) goto fail;
3972p += l; len -= l; ret += l;
3973len = caddr_oldlen - caddr_datalen;
3974}
3975}
3976{
3977size_t authorization_data_datalen, authorization_data_oldlen;
3978Der_type authorization_data_type;
3979e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorization_data_type, 10, &authorization_data_datalen, &l);
3980if (e == 0 && authorization_data_type != CONS) { e = ASN1_BAD_ID; }
3981if(e) {
3982(data)->authorization_data = NULL;
3983} else {
3984(data)->authorization_data = calloc(1, sizeof(*(data)->authorization_data));
3985if ((data)->authorization_data == NULL) { e = ENOMEM; goto fail; }
3986p += l; len -= l; ret += l;
3987authorization_data_oldlen = len;
3988if (authorization_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
3989len = authorization_data_datalen;
3990e = decode_AuthorizationData(p, len, (data)->authorization_data, &l);
3991if(e) goto fail;
3992p += l; len -= l; ret += l;
3993len = authorization_data_oldlen - authorization_data_datalen;
3994}
3995}
3996len = Top_Tag_oldlen - Top_Tag_datalen;
3997}
3998len = Top_oldlen - Top_datalen;
3999}
4000if(size) *size = ret;
4001return 0;
4002fail:
4003free_EncTicketPart(data);
4004return e;
4005}
4006
4007void ASN1CALL
4008free_EncTicketPart(EncTicketPart *data)
4009{
4010free_TicketFlags(&(data)->flags);
4011free_EncryptionKey(&(data)->key);
4012free_Realm(&(data)->crealm);
4013free_PrincipalName(&(data)->cname);
4014free_TransitedEncoding(&(data)->transited);
4015free_KerberosTime(&(data)->authtime);
4016if((data)->starttime) {
4017free_KerberosTime((data)->starttime);
4018free((data)->starttime);
4019(data)->starttime = NULL;
4020}
4021free_KerberosTime(&(data)->endtime);
4022if((data)->renew_till) {
4023free_KerberosTime((data)->renew_till);
4024free((data)->renew_till);
4025(data)->renew_till = NULL;
4026}
4027if((data)->caddr) {
4028free_HostAddresses((data)->caddr);
4029free((data)->caddr);
4030(data)->caddr = NULL;
4031}
4032if((data)->authorization_data) {
4033free_AuthorizationData((data)->authorization_data);
4034free((data)->authorization_data);
4035(data)->authorization_data = NULL;
4036}
4037}
4038
4039size_t ASN1CALL
4040length_EncTicketPart(const EncTicketPart *data)
4041{
4042size_t ret = 0;
4043{
4044size_t Top_tag_tag_oldret = ret;
4045ret = 0;
4046ret += length_TicketFlags(&(data)->flags);
4047ret += 1 + der_length_len (ret);
4048ret += Top_tag_tag_oldret;
4049}
4050{
4051size_t Top_tag_tag_oldret = ret;
4052ret = 0;
4053ret += length_EncryptionKey(&(data)->key);
4054ret += 1 + der_length_len (ret);
4055ret += Top_tag_tag_oldret;
4056}
4057{
4058size_t Top_tag_tag_oldret = ret;
4059ret = 0;
4060ret += length_Realm(&(data)->crealm);
4061ret += 1 + der_length_len (ret);
4062ret += Top_tag_tag_oldret;
4063}
4064{
4065size_t Top_tag_tag_oldret = ret;
4066ret = 0;
4067ret += length_PrincipalName(&(data)->cname);
4068ret += 1 + der_length_len (ret);
4069ret += Top_tag_tag_oldret;
4070}
4071{
4072size_t Top_tag_tag_oldret = ret;
4073ret = 0;
4074ret += length_TransitedEncoding(&(data)->transited);
4075ret += 1 + der_length_len (ret);
4076ret += Top_tag_tag_oldret;
4077}
4078{
4079size_t Top_tag_tag_oldret = ret;
4080ret = 0;
4081ret += length_KerberosTime(&(data)->authtime);
4082ret += 1 + der_length_len (ret);
4083ret += Top_tag_tag_oldret;
4084}
4085if((data)->starttime){
4086size_t Top_tag_tag_oldret = ret;
4087ret = 0;
4088ret += length_KerberosTime((data)->starttime);
4089ret += 1 + der_length_len (ret);
4090ret += Top_tag_tag_oldret;
4091}
4092{
4093size_t Top_tag_tag_oldret = ret;
4094ret = 0;
4095ret += length_KerberosTime(&(data)->endtime);
4096ret += 1 + der_length_len (ret);
4097ret += Top_tag_tag_oldret;
4098}
4099if((data)->renew_till){
4100size_t Top_tag_tag_oldret = ret;
4101ret = 0;
4102ret += length_KerberosTime((data)->renew_till);
4103ret += 1 + der_length_len (ret);
4104ret += Top_tag_tag_oldret;
4105}
4106if((data)->caddr){
4107size_t Top_tag_tag_oldret = ret;
4108ret = 0;
4109ret += length_HostAddresses((data)->caddr);
4110ret += 1 + der_length_len (ret);
4111ret += Top_tag_tag_oldret;
4112}
4113if((data)->authorization_data){
4114size_t Top_tag_tag_oldret = ret;
4115ret = 0;
4116ret += length_AuthorizationData((data)->authorization_data);
4117ret += 1 + der_length_len (ret);
4118ret += Top_tag_tag_oldret;
4119}
4120ret += 1 + der_length_len (ret);
4121ret += 1 + der_length_len (ret);
4122return ret;
4123}
4124
4125int ASN1CALL
4126copy_EncTicketPart(const EncTicketPart *from, EncTicketPart *to)
4127{
4128memset(to, 0, sizeof(*to));
4129if(copy_TicketFlags(&(from)->flags, &(to)->flags)) goto fail;
4130if(copy_EncryptionKey(&(from)->key, &(to)->key)) goto fail;
4131if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
4132if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
4133if(copy_TransitedEncoding(&(from)->transited, &(to)->transited)) goto fail;
4134if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) goto fail;
4135if((from)->starttime) {
4136(to)->starttime = malloc(sizeof(*(to)->starttime));
4137if((to)->starttime == NULL) goto fail;
4138if(copy_KerberosTime((from)->starttime, (to)->starttime)) goto fail;
4139}else
4140(to)->starttime = NULL;
4141if(copy_KerberosTime(&(from)->endtime, &(to)->endtime)) goto fail;
4142if((from)->renew_till) {
4143(to)->renew_till = malloc(sizeof(*(to)->renew_till));
4144if((to)->renew_till == NULL) goto fail;
4145if(copy_KerberosTime((from)->renew_till, (to)->renew_till)) goto fail;
4146}else
4147(to)->renew_till = NULL;
4148if((from)->caddr) {
4149(to)->caddr = malloc(sizeof(*(to)->caddr));
4150if((to)->caddr == NULL) goto fail;
4151if(copy_HostAddresses((from)->caddr, (to)->caddr)) goto fail;
4152}else
4153(to)->caddr = NULL;
4154if((from)->authorization_data) {
4155(to)->authorization_data = malloc(sizeof(*(to)->authorization_data));
4156if((to)->authorization_data == NULL) goto fail;
4157if(copy_AuthorizationData((from)->authorization_data, (to)->authorization_data)) goto fail;
4158}else
4159(to)->authorization_data = NULL;
4160return 0;
4161fail:
4162free_EncTicketPart(to);
4163return ENOMEM;
4164}
4165
4166int ASN1CALL
4167encode_Checksum(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Checksum *data, size_t *size)
4168{
4169size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4170size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4171int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4172
4173/* checksum */
4174{
4175size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4176ret = 0;
4177e = der_put_octet_string(p, len, &(data)->checksum, &l);
4178if (e) return e;
4179p -= l; len -= l; ret += l;
4180
4181e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4182if (e) return e;
4183p -= l; len -= l; ret += l;
4184
4185e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4186if (e) return e;
4187p -= l; len -= l; ret += l;
4188
4189ret += Top_tag_oldret;
4190}
4191/* cksumtype */
4192{
4193size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4194ret = 0;
4195e = encode_CKSUMTYPE(p, len, &(data)->cksumtype, &l);
4196if (e) return e;
4197p -= l; len -= l; ret += l;
4198
4199e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4200if (e) return e;
4201p -= l; len -= l; ret += l;
4202
4203ret += Top_tag_oldret;
4204}
4205e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4206if (e) return e;
4207p -= l; len -= l; ret += l;
4208
4209*size = ret;
4210return 0;
4211}
4212
4213int ASN1CALL
4214decode_Checksum(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Checksum *data, size_t *size)
4215{
4216size_t ret = 0;
4217size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4218int e HEIMDAL_UNUSED_ATTRIBUTE;
4219
4220memset(data, 0, sizeof(*data));
4221{
4222size_t Top_datalen, Top_oldlen;
4223Der_type Top_type;
4224e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4225if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4226if(e) goto fail;
4227p += l; len -= l; ret += l;
4228Top_oldlen = len;
4229if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4230len = Top_datalen;
4231{
4232size_t cksumtype_datalen, cksumtype_oldlen;
4233Der_type cksumtype_type;
4234e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksumtype_type, 0, &cksumtype_datalen, &l);
4235if (e == 0 && cksumtype_type != CONS) { e = ASN1_BAD_ID; }
4236if(e) goto fail;
4237p += l; len -= l; ret += l;
4238cksumtype_oldlen = len;
4239if (cksumtype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4240len = cksumtype_datalen;
4241e = decode_CKSUMTYPE(p, len, &(data)->cksumtype, &l);
4242if(e) goto fail;
4243p += l; len -= l; ret += l;
4244len = cksumtype_oldlen - cksumtype_datalen;
4245}
4246{
4247size_t checksum_datalen, checksum_oldlen;
4248Der_type checksum_type;
4249e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &checksum_type, 1, &checksum_datalen, &l);
4250if (e == 0 && checksum_type != CONS) { e = ASN1_BAD_ID; }
4251if(e) goto fail;
4252p += l; len -= l; ret += l;
4253checksum_oldlen = len;
4254if (checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4255len = checksum_datalen;
4256{
4257size_t checksum_Tag_datalen, checksum_Tag_oldlen;
4258Der_type checksum_Tag_type;
4259e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &checksum_Tag_type, UT_OctetString, &checksum_Tag_datalen, &l);
4260if (e == 0 && checksum_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4261if(e) goto fail;
4262p += l; len -= l; ret += l;
4263checksum_Tag_oldlen = len;
4264if (checksum_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4265len = checksum_Tag_datalen;
4266e = der_get_octet_string(p, len, &(data)->checksum, &l);
4267if(e) goto fail;
4268p += l; len -= l; ret += l;
4269len = checksum_Tag_oldlen - checksum_Tag_datalen;
4270}
4271len = checksum_oldlen - checksum_datalen;
4272}
4273len = Top_oldlen - Top_datalen;
4274}
4275if(size) *size = ret;
4276return 0;
4277fail:
4278free_Checksum(data);
4279return e;
4280}
4281
4282void ASN1CALL
4283free_Checksum(Checksum *data)
4284{
4285free_CKSUMTYPE(&(data)->cksumtype);
4286der_free_octet_string(&(data)->checksum);
4287}
4288
4289size_t ASN1CALL
4290length_Checksum(const Checksum *data)
4291{
4292size_t ret = 0;
4293{
4294size_t Top_tag_oldret = ret;
4295ret = 0;
4296ret += length_CKSUMTYPE(&(data)->cksumtype);
4297ret += 1 + der_length_len (ret);
4298ret += Top_tag_oldret;
4299}
4300{
4301size_t Top_tag_oldret = ret;
4302ret = 0;
4303ret += der_length_octet_string(&(data)->checksum);
4304ret += 1 + der_length_len (ret);
4305ret += 1 + der_length_len (ret);
4306ret += Top_tag_oldret;
4307}
4308ret += 1 + der_length_len (ret);
4309return ret;
4310}
4311
4312int ASN1CALL
4313copy_Checksum(const Checksum *from, Checksum *to)
4314{
4315memset(to, 0, sizeof(*to));
4316if(copy_CKSUMTYPE(&(from)->cksumtype, &(to)->cksumtype)) goto fail;
4317if(der_copy_octet_string(&(from)->checksum, &(to)->checksum)) goto fail;
4318return 0;
4319fail:
4320free_Checksum(to);
4321return ENOMEM;
4322}
4323
4324int ASN1CALL
4325encode_Authenticator(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Authenticator *data, size_t *size)
4326{
4327size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4328size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4329int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4330
4331/* authorization-data */
4332if((data)->authorization_data) {
4333size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4334ret = 0;
4335e = encode_AuthorizationData(p, len, (data)->authorization_data, &l);
4336if (e) return e;
4337p -= l; len -= l; ret += l;
4338
4339e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
4340if (e) return e;
4341p -= l; len -= l; ret += l;
4342
4343ret += Top_tag_tag_oldret;
4344}
4345/* seq-number */
4346if((data)->seq_number) {
4347size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4348ret = 0;
4349e = encode_krb5uint32(p, len, (data)->seq_number, &l);
4350if (e) return e;
4351p -= l; len -= l; ret += l;
4352
4353e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
4354if (e) return e;
4355p -= l; len -= l; ret += l;
4356
4357ret += Top_tag_tag_oldret;
4358}
4359/* subkey */
4360if((data)->subkey) {
4361size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4362ret = 0;
4363e = encode_EncryptionKey(p, len, (data)->subkey, &l);
4364if (e) return e;
4365p -= l; len -= l; ret += l;
4366
4367e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
4368if (e) return e;
4369p -= l; len -= l; ret += l;
4370
4371ret += Top_tag_tag_oldret;
4372}
4373/* ctime */
4374{
4375size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4376ret = 0;
4377e = encode_KerberosTime(p, len, &(data)->ctime, &l);
4378if (e) return e;
4379p -= l; len -= l; ret += l;
4380
4381e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
4382if (e) return e;
4383p -= l; len -= l; ret += l;
4384
4385ret += Top_tag_tag_oldret;
4386}
4387/* cusec */
4388{
4389size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4390ret = 0;
4391e = encode_krb5int32(p, len, &(data)->cusec, &l);
4392if (e) return e;
4393p -= l; len -= l; ret += l;
4394
4395e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
4396if (e) return e;
4397p -= l; len -= l; ret += l;
4398
4399ret += Top_tag_tag_oldret;
4400}
4401/* cksum */
4402if((data)->cksum) {
4403size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4404ret = 0;
4405e = encode_Checksum(p, len, (data)->cksum, &l);
4406if (e) return e;
4407p -= l; len -= l; ret += l;
4408
4409e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
4410if (e) return e;
4411p -= l; len -= l; ret += l;
4412
4413ret += Top_tag_tag_oldret;
4414}
4415/* cname */
4416{
4417size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4418ret = 0;
4419e = encode_PrincipalName(p, len, &(data)->cname, &l);
4420if (e) return e;
4421p -= l; len -= l; ret += l;
4422
4423e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4424if (e) return e;
4425p -= l; len -= l; ret += l;
4426
4427ret += Top_tag_tag_oldret;
4428}
4429/* crealm */
4430{
4431size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4432ret = 0;
4433e = encode_Realm(p, len, &(data)->crealm, &l);
4434if (e) return e;
4435p -= l; len -= l; ret += l;
4436
4437e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4438if (e) return e;
4439p -= l; len -= l; ret += l;
4440
4441ret += Top_tag_tag_oldret;
4442}
4443/* authenticator-vno */
4444{
4445size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4446ret = 0;
4447e = encode_krb5int32(p, len, &(data)->authenticator_vno, &l);
4448if (e) return e;
4449p -= l; len -= l; ret += l;
4450
4451e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4452if (e) return e;
4453p -= l; len -= l; ret += l;
4454
4455ret += Top_tag_tag_oldret;
4456}
4457e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4458if (e) return e;
4459p -= l; len -= l; ret += l;
4460
4461e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 2, &l);
4462if (e) return e;
4463p -= l; len -= l; ret += l;
4464
4465*size = ret;
4466return 0;
4467}
4468
4469int ASN1CALL
4470decode_Authenticator(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Authenticator *data, size_t *size)
4471{
4472size_t ret = 0;
4473size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4474int e HEIMDAL_UNUSED_ATTRIBUTE;
4475
4476memset(data, 0, sizeof(*data));
4477{
4478size_t Top_datalen, Top_oldlen;
4479Der_type Top_type;
4480e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 2, &Top_datalen, &l);
4481if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4482if(e) goto fail;
4483p += l; len -= l; ret += l;
4484Top_oldlen = len;
4485if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4486len = Top_datalen;
4487{
4488size_t Top_Tag_datalen, Top_Tag_oldlen;
4489Der_type Top_Tag_type;
4490e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
4491if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
4492if(e) goto fail;
4493p += l; len -= l; ret += l;
4494Top_Tag_oldlen = len;
4495if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4496len = Top_Tag_datalen;
4497{
4498size_t authenticator_vno_datalen, authenticator_vno_oldlen;
4499Der_type authenticator_vno_type;
4500e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authenticator_vno_type, 0, &authenticator_vno_datalen, &l);
4501if (e == 0 && authenticator_vno_type != CONS) { e = ASN1_BAD_ID; }
4502if(e) goto fail;
4503p += l; len -= l; ret += l;
4504authenticator_vno_oldlen = len;
4505if (authenticator_vno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4506len = authenticator_vno_datalen;
4507e = decode_krb5int32(p, len, &(data)->authenticator_vno, &l);
4508if(e) goto fail;
4509p += l; len -= l; ret += l;
4510len = authenticator_vno_oldlen - authenticator_vno_datalen;
4511}
4512{
4513size_t crealm_datalen, crealm_oldlen;
4514Der_type crealm_type;
4515e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 1, &crealm_datalen, &l);
4516if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
4517if(e) goto fail;
4518p += l; len -= l; ret += l;
4519crealm_oldlen = len;
4520if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4521len = crealm_datalen;
4522e = decode_Realm(p, len, &(data)->crealm, &l);
4523if(e) goto fail;
4524p += l; len -= l; ret += l;
4525len = crealm_oldlen - crealm_datalen;
4526}
4527{
4528size_t cname_datalen, cname_oldlen;
4529Der_type cname_type;
4530e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 2, &cname_datalen, &l);
4531if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
4532if(e) goto fail;
4533p += l; len -= l; ret += l;
4534cname_oldlen = len;
4535if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4536len = cname_datalen;
4537e = decode_PrincipalName(p, len, &(data)->cname, &l);
4538if(e) goto fail;
4539p += l; len -= l; ret += l;
4540len = cname_oldlen - cname_datalen;
4541}
4542{
4543size_t cksum_datalen, cksum_oldlen;
4544Der_type cksum_type;
4545e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 3, &cksum_datalen, &l);
4546if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
4547if(e) {
4548(data)->cksum = NULL;
4549} else {
4550(data)->cksum = calloc(1, sizeof(*(data)->cksum));
4551if ((data)->cksum == NULL) { e = ENOMEM; goto fail; }
4552p += l; len -= l; ret += l;
4553cksum_oldlen = len;
4554if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4555len = cksum_datalen;
4556e = decode_Checksum(p, len, (data)->cksum, &l);
4557if(e) goto fail;
4558p += l; len -= l; ret += l;
4559len = cksum_oldlen - cksum_datalen;
4560}
4561}
4562{
4563size_t cusec_datalen, cusec_oldlen;
4564Der_type cusec_type;
4565e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cusec_type, 4, &cusec_datalen, &l);
4566if (e == 0 && cusec_type != CONS) { e = ASN1_BAD_ID; }
4567if(e) goto fail;
4568p += l; len -= l; ret += l;
4569cusec_oldlen = len;
4570if (cusec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4571len = cusec_datalen;
4572e = decode_krb5int32(p, len, &(data)->cusec, &l);
4573if(e) goto fail;
4574p += l; len -= l; ret += l;
4575len = cusec_oldlen - cusec_datalen;
4576}
4577{
4578size_t ctime_datalen, ctime_oldlen;
4579Der_type ctime_type;
4580e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ctime_type, 5, &ctime_datalen, &l);
4581if (e == 0 && ctime_type != CONS) { e = ASN1_BAD_ID; }
4582if(e) goto fail;
4583p += l; len -= l; ret += l;
4584ctime_oldlen = len;
4585if (ctime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4586len = ctime_datalen;
4587e = decode_KerberosTime(p, len, &(data)->ctime, &l);
4588if(e) goto fail;
4589p += l; len -= l; ret += l;
4590len = ctime_oldlen - ctime_datalen;
4591}
4592{
4593size_t subkey_datalen, subkey_oldlen;
4594Der_type subkey_type;
4595e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subkey_type, 6, &subkey_datalen, &l);
4596if (e == 0 && subkey_type != CONS) { e = ASN1_BAD_ID; }
4597if(e) {
4598(data)->subkey = NULL;
4599} else {
4600(data)->subkey = calloc(1, sizeof(*(data)->subkey));
4601if ((data)->subkey == NULL) { e = ENOMEM; goto fail; }
4602p += l; len -= l; ret += l;
4603subkey_oldlen = len;
4604if (subkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4605len = subkey_datalen;
4606e = decode_EncryptionKey(p, len, (data)->subkey, &l);
4607if(e) goto fail;
4608p += l; len -= l; ret += l;
4609len = subkey_oldlen - subkey_datalen;
4610}
4611}
4612{
4613size_t seq_number_datalen, seq_number_oldlen;
4614Der_type seq_number_type;
4615e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 7, &seq_number_datalen, &l);
4616if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
4617if(e) {
4618(data)->seq_number = NULL;
4619} else {
4620(data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
4621if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
4622p += l; len -= l; ret += l;
4623seq_number_oldlen = len;
4624if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4625len = seq_number_datalen;
4626e = decode_krb5uint32(p, len, (data)->seq_number, &l);
4627if(e) goto fail;
4628p += l; len -= l; ret += l;
4629len = seq_number_oldlen - seq_number_datalen;
4630}
4631}
4632{
4633size_t authorization_data_datalen, authorization_data_oldlen;
4634Der_type authorization_data_type;
4635e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorization_data_type, 8, &authorization_data_datalen, &l);
4636if (e == 0 && authorization_data_type != CONS) { e = ASN1_BAD_ID; }
4637if(e) {
4638(data)->authorization_data = NULL;
4639} else {
4640(data)->authorization_data = calloc(1, sizeof(*(data)->authorization_data));
4641if ((data)->authorization_data == NULL) { e = ENOMEM; goto fail; }
4642p += l; len -= l; ret += l;
4643authorization_data_oldlen = len;
4644if (authorization_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4645len = authorization_data_datalen;
4646e = decode_AuthorizationData(p, len, (data)->authorization_data, &l);
4647if(e) goto fail;
4648p += l; len -= l; ret += l;
4649len = authorization_data_oldlen - authorization_data_datalen;
4650}
4651}
4652len = Top_Tag_oldlen - Top_Tag_datalen;
4653}
4654len = Top_oldlen - Top_datalen;
4655}
4656if(size) *size = ret;
4657return 0;
4658fail:
4659free_Authenticator(data);
4660return e;
4661}
4662
4663void ASN1CALL
4664free_Authenticator(Authenticator *data)
4665{
4666free_krb5int32(&(data)->authenticator_vno);
4667free_Realm(&(data)->crealm);
4668free_PrincipalName(&(data)->cname);
4669if((data)->cksum) {
4670free_Checksum((data)->cksum);
4671free((data)->cksum);
4672(data)->cksum = NULL;
4673}
4674free_krb5int32(&(data)->cusec);
4675free_KerberosTime(&(data)->ctime);
4676if((data)->subkey) {
4677free_EncryptionKey((data)->subkey);
4678free((data)->subkey);
4679(data)->subkey = NULL;
4680}
4681if((data)->seq_number) {
4682free_krb5uint32((data)->seq_number);
4683free((data)->seq_number);
4684(data)->seq_number = NULL;
4685}
4686if((data)->authorization_data) {
4687free_AuthorizationData((data)->authorization_data);
4688free((data)->authorization_data);
4689(data)->authorization_data = NULL;
4690}
4691}
4692
4693size_t ASN1CALL
4694length_Authenticator(const Authenticator *data)
4695{
4696size_t ret = 0;
4697{
4698size_t Top_tag_tag_oldret = ret;
4699ret = 0;
4700ret += length_krb5int32(&(data)->authenticator_vno);
4701ret += 1 + der_length_len (ret);
4702ret += Top_tag_tag_oldret;
4703}
4704{
4705size_t Top_tag_tag_oldret = ret;
4706ret = 0;
4707ret += length_Realm(&(data)->crealm);
4708ret += 1 + der_length_len (ret);
4709ret += Top_tag_tag_oldret;
4710}
4711{
4712size_t Top_tag_tag_oldret = ret;
4713ret = 0;
4714ret += length_PrincipalName(&(data)->cname);
4715ret += 1 + der_length_len (ret);
4716ret += Top_tag_tag_oldret;
4717}
4718if((data)->cksum){
4719size_t Top_tag_tag_oldret = ret;
4720ret = 0;
4721ret += length_Checksum((data)->cksum);
4722ret += 1 + der_length_len (ret);
4723ret += Top_tag_tag_oldret;
4724}
4725{
4726size_t Top_tag_tag_oldret = ret;
4727ret = 0;
4728ret += length_krb5int32(&(data)->cusec);
4729ret += 1 + der_length_len (ret);
4730ret += Top_tag_tag_oldret;
4731}
4732{
4733size_t Top_tag_tag_oldret = ret;
4734ret = 0;
4735ret += length_KerberosTime(&(data)->ctime);
4736ret += 1 + der_length_len (ret);
4737ret += Top_tag_tag_oldret;
4738}
4739if((data)->subkey){
4740size_t Top_tag_tag_oldret = ret;
4741ret = 0;
4742ret += length_EncryptionKey((data)->subkey);
4743ret += 1 + der_length_len (ret);
4744ret += Top_tag_tag_oldret;
4745}
4746if((data)->seq_number){
4747size_t Top_tag_tag_oldret = ret;
4748ret = 0;
4749ret += length_krb5uint32((data)->seq_number);
4750ret += 1 + der_length_len (ret);
4751ret += Top_tag_tag_oldret;
4752}
4753if((data)->authorization_data){
4754size_t Top_tag_tag_oldret = ret;
4755ret = 0;
4756ret += length_AuthorizationData((data)->authorization_data);
4757ret += 1 + der_length_len (ret);
4758ret += Top_tag_tag_oldret;
4759}
4760ret += 1 + der_length_len (ret);
4761ret += 1 + der_length_len (ret);
4762return ret;
4763}
4764
4765int ASN1CALL
4766copy_Authenticator(const Authenticator *from, Authenticator *to)
4767{
4768memset(to, 0, sizeof(*to));
4769if(copy_krb5int32(&(from)->authenticator_vno, &(to)->authenticator_vno)) goto fail;
4770if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
4771if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
4772if((from)->cksum) {
4773(to)->cksum = malloc(sizeof(*(to)->cksum));
4774if((to)->cksum == NULL) goto fail;
4775if(copy_Checksum((from)->cksum, (to)->cksum)) goto fail;
4776}else
4777(to)->cksum = NULL;
4778if(copy_krb5int32(&(from)->cusec, &(to)->cusec)) goto fail;
4779if(copy_KerberosTime(&(from)->ctime, &(to)->ctime)) goto fail;
4780if((from)->subkey) {
4781(to)->subkey = malloc(sizeof(*(to)->subkey));
4782if((to)->subkey == NULL) goto fail;
4783if(copy_EncryptionKey((from)->subkey, (to)->subkey)) goto fail;
4784}else
4785(to)->subkey = NULL;
4786if((from)->seq_number) {
4787(to)->seq_number = malloc(sizeof(*(to)->seq_number));
4788if((to)->seq_number == NULL) goto fail;
4789if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
4790}else
4791(to)->seq_number = NULL;
4792if((from)->authorization_data) {
4793(to)->authorization_data = malloc(sizeof(*(to)->authorization_data));
4794if((to)->authorization_data == NULL) goto fail;
4795if(copy_AuthorizationData((from)->authorization_data, (to)->authorization_data)) goto fail;
4796}else
4797(to)->authorization_data = NULL;
4798return 0;
4799fail:
4800free_Authenticator(to);
4801return ENOMEM;
4802}
4803
4804int ASN1CALL
4805encode_PA_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_DATA *data, size_t *size)
4806{
4807size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4808size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4809int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4810
4811/* padata-value */
4812{
4813size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4814ret = 0;
4815e = der_put_octet_string(p, len, &(data)->padata_value, &l);
4816if (e) return e;
4817p -= l; len -= l; ret += l;
4818
4819e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4820if (e) return e;
4821p -= l; len -= l; ret += l;
4822
4823e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4824if (e) return e;
4825p -= l; len -= l; ret += l;
4826
4827ret += Top_tag_oldret;
4828}
4829/* padata-type */
4830{
4831size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4832ret = 0;
4833e = encode_PADATA_TYPE(p, len, &(data)->padata_type, &l);
4834if (e) return e;
4835p -= l; len -= l; ret += l;
4836
4837e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4838if (e) return e;
4839p -= l; len -= l; ret += l;
4840
4841ret += Top_tag_oldret;
4842}
4843e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4844if (e) return e;
4845p -= l; len -= l; ret += l;
4846
4847*size = ret;
4848return 0;
4849}
4850
4851int ASN1CALL
4852decode_PA_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_DATA *data, size_t *size)
4853{
4854size_t ret = 0;
4855size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4856int e HEIMDAL_UNUSED_ATTRIBUTE;
4857
4858memset(data, 0, sizeof(*data));
4859{
4860size_t Top_datalen, Top_oldlen;
4861Der_type Top_type;
4862e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4863if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4864if(e) goto fail;
4865p += l; len -= l; ret += l;
4866Top_oldlen = len;
4867if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4868len = Top_datalen;
4869{
4870size_t padata_type_datalen, padata_type_oldlen;
4871Der_type padata_type_type;
4872e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type_type, 1, &padata_type_datalen, &l);
4873if (e == 0 && padata_type_type != CONS) { e = ASN1_BAD_ID; }
4874if(e) goto fail;
4875p += l; len -= l; ret += l;
4876padata_type_oldlen = len;
4877if (padata_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4878len = padata_type_datalen;
4879e = decode_PADATA_TYPE(p, len, &(data)->padata_type, &l);
4880if(e) goto fail;
4881p += l; len -= l; ret += l;
4882len = padata_type_oldlen - padata_type_datalen;
4883}
4884{
4885size_t padata_value_datalen, padata_value_oldlen;
4886Der_type padata_value_type;
4887e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_value_type, 2, &padata_value_datalen, &l);
4888if (e == 0 && padata_value_type != CONS) { e = ASN1_BAD_ID; }
4889if(e) goto fail;
4890p += l; len -= l; ret += l;
4891padata_value_oldlen = len;
4892if (padata_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4893len = padata_value_datalen;
4894{
4895size_t padata_value_Tag_datalen, padata_value_Tag_oldlen;
4896Der_type padata_value_Tag_type;
4897e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &padata_value_Tag_type, UT_OctetString, &padata_value_Tag_datalen, &l);
4898if (e == 0 && padata_value_Tag_type != PRIM) { e = ASN1_BAD_ID; }
4899if(e) goto fail;
4900p += l; len -= l; ret += l;
4901padata_value_Tag_oldlen = len;
4902if (padata_value_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
4903len = padata_value_Tag_datalen;
4904e = der_get_octet_string(p, len, &(data)->padata_value, &l);
4905if(e) goto fail;
4906p += l; len -= l; ret += l;
4907len = padata_value_Tag_oldlen - padata_value_Tag_datalen;
4908}
4909len = padata_value_oldlen - padata_value_datalen;
4910}
4911len = Top_oldlen - Top_datalen;
4912}
4913if(size) *size = ret;
4914return 0;
4915fail:
4916free_PA_DATA(data);
4917return e;
4918}
4919
4920void ASN1CALL
4921free_PA_DATA(PA_DATA *data)
4922{
4923free_PADATA_TYPE(&(data)->padata_type);
4924der_free_octet_string(&(data)->padata_value);
4925}
4926
4927size_t ASN1CALL
4928length_PA_DATA(const PA_DATA *data)
4929{
4930size_t ret = 0;
4931{
4932size_t Top_tag_oldret = ret;
4933ret = 0;
4934ret += length_PADATA_TYPE(&(data)->padata_type);
4935ret += 1 + der_length_len (ret);
4936ret += Top_tag_oldret;
4937}
4938{
4939size_t Top_tag_oldret = ret;
4940ret = 0;
4941ret += der_length_octet_string(&(data)->padata_value);
4942ret += 1 + der_length_len (ret);
4943ret += 1 + der_length_len (ret);
4944ret += Top_tag_oldret;
4945}
4946ret += 1 + der_length_len (ret);
4947return ret;
4948}
4949
4950int ASN1CALL
4951copy_PA_DATA(const PA_DATA *from, PA_DATA *to)
4952{
4953memset(to, 0, sizeof(*to));
4954if(copy_PADATA_TYPE(&(from)->padata_type, &(to)->padata_type)) goto fail;
4955if(der_copy_octet_string(&(from)->padata_value, &(to)->padata_value)) goto fail;
4956return 0;
4957fail:
4958free_PA_DATA(to);
4959return ENOMEM;
4960}
4961
4962int ASN1CALL
4963encode_ETYPE_INFO_ENTRY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO_ENTRY *data, size_t *size)
4964{
4965size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4966size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4967int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4968
4969/* salttype */
4970if((data)->salttype) {
4971size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4972ret = 0;
4973e = encode_krb5int32(p, len, (data)->salttype, &l);
4974if (e) return e;
4975p -= l; len -= l; ret += l;
4976
4977e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
4978if (e) return e;
4979p -= l; len -= l; ret += l;
4980
4981ret += Top_tag_oldret;
4982}
4983/* salt */
4984if((data)->salt) {
4985size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4986ret = 0;
4987e = der_put_octet_string(p, len, (data)->salt, &l);
4988if (e) return e;
4989p -= l; len -= l; ret += l;
4990
4991e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4992if (e) return e;
4993p -= l; len -= l; ret += l;
4994
4995e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4996if (e) return e;
4997p -= l; len -= l; ret += l;
4998
4999ret += Top_tag_oldret;
5000}
5001/* etype */
5002{
5003size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5004ret = 0;
5005e = encode_ENCTYPE(p, len, &(data)->etype, &l);
5006if (e) return e;
5007p -= l; len -= l; ret += l;
5008
5009e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5010if (e) return e;
5011p -= l; len -= l; ret += l;
5012
5013ret += Top_tag_oldret;
5014}
5015e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5016if (e) return e;
5017p -= l; len -= l; ret += l;
5018
5019*size = ret;
5020return 0;
5021}
5022
5023int ASN1CALL
5024decode_ETYPE_INFO_ENTRY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO_ENTRY *data, size_t *size)
5025{
5026size_t ret = 0;
5027size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5028int e HEIMDAL_UNUSED_ATTRIBUTE;
5029
5030memset(data, 0, sizeof(*data));
5031{
5032size_t Top_datalen, Top_oldlen;
5033Der_type Top_type;
5034e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5035if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5036if(e) goto fail;
5037p += l; len -= l; ret += l;
5038Top_oldlen = len;
5039if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5040len = Top_datalen;
5041{
5042size_t etype_datalen, etype_oldlen;
5043Der_type etype_type;
5044e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
5045if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
5046if(e) goto fail;
5047p += l; len -= l; ret += l;
5048etype_oldlen = len;
5049if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5050len = etype_datalen;
5051e = decode_ENCTYPE(p, len, &(data)->etype, &l);
5052if(e) goto fail;
5053p += l; len -= l; ret += l;
5054len = etype_oldlen - etype_datalen;
5055}
5056{
5057size_t salt_datalen, salt_oldlen;
5058Der_type salt_type;
5059e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salt_type, 1, &salt_datalen, &l);
5060if (e == 0 && salt_type != CONS) { e = ASN1_BAD_ID; }
5061if(e) {
5062(data)->salt = NULL;
5063} else {
5064(data)->salt = calloc(1, sizeof(*(data)->salt));
5065if ((data)->salt == NULL) { e = ENOMEM; goto fail; }
5066p += l; len -= l; ret += l;
5067salt_oldlen = len;
5068if (salt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5069len = salt_datalen;
5070{
5071size_t salt_Tag_datalen, salt_Tag_oldlen;
5072Der_type salt_Tag_type;
5073e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &salt_Tag_type, UT_OctetString, &salt_Tag_datalen, &l);
5074if (e == 0 && salt_Tag_type != PRIM) { e = ASN1_BAD_ID; }
5075if(e) goto fail;
5076p += l; len -= l; ret += l;
5077salt_Tag_oldlen = len;
5078if (salt_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5079len = salt_Tag_datalen;
5080e = der_get_octet_string(p, len, (data)->salt, &l);
5081if(e) goto fail;
5082p += l; len -= l; ret += l;
5083len = salt_Tag_oldlen - salt_Tag_datalen;
5084}
5085len = salt_oldlen - salt_datalen;
5086}
5087}
5088{
5089size_t salttype_datalen, salttype_oldlen;
5090Der_type salttype_type;
5091e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salttype_type, 2, &salttype_datalen, &l);
5092if (e == 0 && salttype_type != CONS) { e = ASN1_BAD_ID; }
5093if(e) {
5094(data)->salttype = NULL;
5095} else {
5096(data)->salttype = calloc(1, sizeof(*(data)->salttype));
5097if ((data)->salttype == NULL) { e = ENOMEM; goto fail; }
5098p += l; len -= l; ret += l;
5099salttype_oldlen = len;
5100if (salttype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5101len = salttype_datalen;
5102e = decode_krb5int32(p, len, (data)->salttype, &l);
5103if(e) goto fail;
5104p += l; len -= l; ret += l;
5105len = salttype_oldlen - salttype_datalen;
5106}
5107}
5108len = Top_oldlen - Top_datalen;
5109}
5110if(size) *size = ret;
5111return 0;
5112fail:
5113free_ETYPE_INFO_ENTRY(data);
5114return e;
5115}
5116
5117void ASN1CALL
5118free_ETYPE_INFO_ENTRY(ETYPE_INFO_ENTRY *data)
5119{
5120free_ENCTYPE(&(data)->etype);
5121if((data)->salt) {
5122der_free_octet_string((data)->salt);
5123free((data)->salt);
5124(data)->salt = NULL;
5125}
5126if((data)->salttype) {
5127free_krb5int32((data)->salttype);
5128free((data)->salttype);
5129(data)->salttype = NULL;
5130}
5131}
5132
5133size_t ASN1CALL
5134length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *data)
5135{
5136size_t ret = 0;
5137{
5138size_t Top_tag_oldret = ret;
5139ret = 0;
5140ret += length_ENCTYPE(&(data)->etype);
5141ret += 1 + der_length_len (ret);
5142ret += Top_tag_oldret;
5143}
5144if((data)->salt){
5145size_t Top_tag_oldret = ret;
5146ret = 0;
5147ret += der_length_octet_string((data)->salt);
5148ret += 1 + der_length_len (ret);
5149ret += 1 + der_length_len (ret);
5150ret += Top_tag_oldret;
5151}
5152if((data)->salttype){
5153size_t Top_tag_oldret = ret;
5154ret = 0;
5155ret += length_krb5int32((data)->salttype);
5156ret += 1 + der_length_len (ret);
5157ret += Top_tag_oldret;
5158}
5159ret += 1 + der_length_len (ret);
5160return ret;
5161}
5162
5163int ASN1CALL
5164copy_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *from, ETYPE_INFO_ENTRY *to)
5165{
5166memset(to, 0, sizeof(*to));
5167if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
5168if((from)->salt) {
5169(to)->salt = malloc(sizeof(*(to)->salt));
5170if((to)->salt == NULL) goto fail;
5171if(der_copy_octet_string((from)->salt, (to)->salt)) goto fail;
5172}else
5173(to)->salt = NULL;
5174if((from)->salttype) {
5175(to)->salttype = malloc(sizeof(*(to)->salttype));
5176if((to)->salttype == NULL) goto fail;
5177if(copy_krb5int32((from)->salttype, (to)->salttype)) goto fail;
5178}else
5179(to)->salttype = NULL;
5180return 0;
5181fail:
5182free_ETYPE_INFO_ENTRY(to);
5183return ENOMEM;
5184}
5185
5186int ASN1CALL
5187encode_ETYPE_INFO(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO *data, size_t *size)
5188{
5189size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5190size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5191int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5192
5193for(i = (int)(data)->len - 1; i >= 0; --i) {
5194size_t Top_tag_for_oldret = ret;
5195ret = 0;
5196e = encode_ETYPE_INFO_ENTRY(p, len, &(data)->val[i], &l);
5197if (e) return e;
5198p -= l; len -= l; ret += l;
5199
5200ret += Top_tag_for_oldret;
5201}
5202e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5203if (e) return e;
5204p -= l; len -= l; ret += l;
5205
5206*size = ret;
5207return 0;
5208}
5209
5210int ASN1CALL
5211decode_ETYPE_INFO(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO *data, size_t *size)
5212{
5213size_t ret = 0;
5214size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5215int e HEIMDAL_UNUSED_ATTRIBUTE;
5216
5217memset(data, 0, sizeof(*data));
5218{
5219size_t Top_datalen, Top_oldlen;
5220Der_type Top_type;
5221e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5222if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5223if(e) goto fail;
5224p += l; len -= l; ret += l;
5225Top_oldlen = len;
5226if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5227len = Top_datalen;
5228{
5229size_t Top_Tag_origlen = len;
5230size_t Top_Tag_oldret = ret;
5231size_t Top_Tag_olen = 0;
5232void *Top_Tag_tmp;
5233ret = 0;
5234(data)->len = 0;
5235(data)->val = NULL;
5236while(ret < Top_Tag_origlen) {
5237size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
5238if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5239Top_Tag_olen = Top_Tag_nlen;
5240Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
5241if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5242(data)->val = Top_Tag_tmp;
5243e = decode_ETYPE_INFO_ENTRY(p, len, &(data)->val[(data)->len], &l);
5244if(e) goto fail;
5245p += l; len -= l; ret += l;
5246(data)->len++;
5247len = Top_Tag_origlen - ret;
5248}
5249ret += Top_Tag_oldret;
5250}
5251len = Top_oldlen - Top_datalen;
5252}
5253if(size) *size = ret;
5254return 0;
5255fail:
5256free_ETYPE_INFO(data);
5257return e;
5258}
5259
5260void ASN1CALL
5261free_ETYPE_INFO(ETYPE_INFO *data)
5262{
5263while((data)->len){
5264free_ETYPE_INFO_ENTRY(&(data)->val[(data)->len-1]);
5265(data)->len--;
5266}
5267free((data)->val);
5268(data)->val = NULL;
5269}
5270
5271size_t ASN1CALL
5272length_ETYPE_INFO(const ETYPE_INFO *data)
5273{
5274size_t ret = 0;
5275{
5276size_t Top_tag_oldret = ret;
5277unsigned int n_Top_tag;
5278ret = 0;
5279for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
5280size_t Top_tag_for_oldret = ret;
5281ret = 0;
5282ret += length_ETYPE_INFO_ENTRY(&(data)->val[n_Top_tag - 1]);
5283ret += Top_tag_for_oldret;
5284}
5285ret += Top_tag_oldret;
5286}
5287ret += 1 + der_length_len (ret);
5288return ret;
5289}
5290
5291int ASN1CALL
5292copy_ETYPE_INFO(const ETYPE_INFO *from, ETYPE_INFO *to)
5293{
5294memset(to, 0, sizeof(*to));
5295if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
5296goto fail;
5297for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
5298if(copy_ETYPE_INFO_ENTRY(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
5299}
5300return 0;
5301fail:
5302free_ETYPE_INFO(to);
5303return ENOMEM;
5304}
5305
5306int ASN1CALL
5307add_ETYPE_INFO(ETYPE_INFO *data, const ETYPE_INFO_ENTRY *element)
5308{
5309int ret;
5310void *ptr;
5311
5312ptr = realloc(data->val,
5313 (data->len + 1) * sizeof(data->val[0]));
5314if (ptr == NULL) return ENOMEM;
5315data->val = ptr;
5316
5317ret = copy_ETYPE_INFO_ENTRY(element, &data->val[data->len]);
5318if (ret) return ret;
5319data->len++;
5320return 0;
5321}
5322
5323int ASN1CALL
5324remove_ETYPE_INFO(ETYPE_INFO *data, unsigned int element)
5325{
5326void *ptr;
5327
5328if (data->len == 0 || element >= data->len)
5329 return ASN1_OVERRUN;
5330free_ETYPE_INFO_ENTRY(&data->val[element]);
5331data->len--;
5332if (element < data->len)
5333 memmove(&data->val[element], &data->val[element + 1],
5334 sizeof(data->val[0]) * (data->len - element));
5335ptr = realloc(data->val, data->len * sizeof(data->val[0]));
5336if (ptr != NULL || data->len == 0) data->val = ptr;
5337return 0;
5338}
5339
5340int ASN1CALL
5341encode_ETYPE_INFO2_ENTRY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO2_ENTRY *data, size_t *size)
5342{
5343size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5344size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5345int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5346
5347/* s2kparams */
5348if((data)->s2kparams) {
5349size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5350ret = 0;
5351e = der_put_octet_string(p, len, (data)->s2kparams, &l);
5352if (e) return e;
5353p -= l; len -= l; ret += l;
5354
5355e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
5356if (e) return e;
5357p -= l; len -= l; ret += l;
5358
5359e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
5360if (e) return e;
5361p -= l; len -= l; ret += l;
5362
5363ret += Top_tag_oldret;
5364}
5365/* salt */
5366if((data)->salt) {
5367size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5368ret = 0;
5369e = encode_KerberosString(p, len, (data)->salt, &l);
5370if (e) return e;
5371p -= l; len -= l; ret += l;
5372
5373e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
5374if (e) return e;
5375p -= l; len -= l; ret += l;
5376
5377ret += Top_tag_oldret;
5378}
5379/* etype */
5380{
5381size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5382ret = 0;
5383e = encode_ENCTYPE(p, len, &(data)->etype, &l);
5384if (e) return e;
5385p -= l; len -= l; ret += l;
5386
5387e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5388if (e) return e;
5389p -= l; len -= l; ret += l;
5390
5391ret += Top_tag_oldret;
5392}
5393e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5394if (e) return e;
5395p -= l; len -= l; ret += l;
5396
5397*size = ret;
5398return 0;
5399}
5400
5401int ASN1CALL
5402decode_ETYPE_INFO2_ENTRY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO2_ENTRY *data, size_t *size)
5403{
5404size_t ret = 0;
5405size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5406int e HEIMDAL_UNUSED_ATTRIBUTE;
5407
5408memset(data, 0, sizeof(*data));
5409{
5410size_t Top_datalen, Top_oldlen;
5411Der_type Top_type;
5412e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5413if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5414if(e) goto fail;
5415p += l; len -= l; ret += l;
5416Top_oldlen = len;
5417if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5418len = Top_datalen;
5419{
5420size_t etype_datalen, etype_oldlen;
5421Der_type etype_type;
5422e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
5423if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
5424if(e) goto fail;
5425p += l; len -= l; ret += l;
5426etype_oldlen = len;
5427if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5428len = etype_datalen;
5429e = decode_ENCTYPE(p, len, &(data)->etype, &l);
5430if(e) goto fail;
5431p += l; len -= l; ret += l;
5432len = etype_oldlen - etype_datalen;
5433}
5434{
5435size_t salt_datalen, salt_oldlen;
5436Der_type salt_type;
5437e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &salt_type, 1, &salt_datalen, &l);
5438if (e == 0 && salt_type != CONS) { e = ASN1_BAD_ID; }
5439if(e) {
5440(data)->salt = NULL;
5441} else {
5442(data)->salt = calloc(1, sizeof(*(data)->salt));
5443if ((data)->salt == NULL) { e = ENOMEM; goto fail; }
5444p += l; len -= l; ret += l;
5445salt_oldlen = len;
5446if (salt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5447len = salt_datalen;
5448e = decode_KerberosString(p, len, (data)->salt, &l);
5449if(e) goto fail;
5450p += l; len -= l; ret += l;
5451len = salt_oldlen - salt_datalen;
5452}
5453}
5454{
5455size_t s2kparams_datalen, s2kparams_oldlen;
5456Der_type s2kparams_type;
5457e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s2kparams_type, 2, &s2kparams_datalen, &l);
5458if (e == 0 && s2kparams_type != CONS) { e = ASN1_BAD_ID; }
5459if(e) {
5460(data)->s2kparams = NULL;
5461} else {
5462(data)->s2kparams = calloc(1, sizeof(*(data)->s2kparams));
5463if ((data)->s2kparams == NULL) { e = ENOMEM; goto fail; }
5464p += l; len -= l; ret += l;
5465s2kparams_oldlen = len;
5466if (s2kparams_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5467len = s2kparams_datalen;
5468{
5469size_t s2kparams_Tag_datalen, s2kparams_Tag_oldlen;
5470Der_type s2kparams_Tag_type;
5471e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &s2kparams_Tag_type, UT_OctetString, &s2kparams_Tag_datalen, &l);
5472if (e == 0 && s2kparams_Tag_type != PRIM) { e = ASN1_BAD_ID; }
5473if(e) goto fail;
5474p += l; len -= l; ret += l;
5475s2kparams_Tag_oldlen = len;
5476if (s2kparams_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5477len = s2kparams_Tag_datalen;
5478e = der_get_octet_string(p, len, (data)->s2kparams, &l);
5479if(e) goto fail;
5480p += l; len -= l; ret += l;
5481len = s2kparams_Tag_oldlen - s2kparams_Tag_datalen;
5482}
5483len = s2kparams_oldlen - s2kparams_datalen;
5484}
5485}
5486len = Top_oldlen - Top_datalen;
5487}
5488if(size) *size = ret;
5489return 0;
5490fail:
5491free_ETYPE_INFO2_ENTRY(data);
5492return e;
5493}
5494
5495void ASN1CALL
5496free_ETYPE_INFO2_ENTRY(ETYPE_INFO2_ENTRY *data)
5497{
5498free_ENCTYPE(&(data)->etype);
5499if((data)->salt) {
5500free_KerberosString((data)->salt);
5501free((data)->salt);
5502(data)->salt = NULL;
5503}
5504if((data)->s2kparams) {
5505der_free_octet_string((data)->s2kparams);
5506free((data)->s2kparams);
5507(data)->s2kparams = NULL;
5508}
5509}
5510
5511size_t ASN1CALL
5512length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *data)
5513{
5514size_t ret = 0;
5515{
5516size_t Top_tag_oldret = ret;
5517ret = 0;
5518ret += length_ENCTYPE(&(data)->etype);
5519ret += 1 + der_length_len (ret);
5520ret += Top_tag_oldret;
5521}
5522if((data)->salt){
5523size_t Top_tag_oldret = ret;
5524ret = 0;
5525ret += length_KerberosString((data)->salt);
5526ret += 1 + der_length_len (ret);
5527ret += Top_tag_oldret;
5528}
5529if((data)->s2kparams){
5530size_t Top_tag_oldret = ret;
5531ret = 0;
5532ret += der_length_octet_string((data)->s2kparams);
5533ret += 1 + der_length_len (ret);
5534ret += 1 + der_length_len (ret);
5535ret += Top_tag_oldret;
5536}
5537ret += 1 + der_length_len (ret);
5538return ret;
5539}
5540
5541int ASN1CALL
5542copy_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *from, ETYPE_INFO2_ENTRY *to)
5543{
5544memset(to, 0, sizeof(*to));
5545if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
5546if((from)->salt) {
5547(to)->salt = malloc(sizeof(*(to)->salt));
5548if((to)->salt == NULL) goto fail;
5549if(copy_KerberosString((from)->salt, (to)->salt)) goto fail;
5550}else
5551(to)->salt = NULL;
5552if((from)->s2kparams) {
5553(to)->s2kparams = malloc(sizeof(*(to)->s2kparams));
5554if((to)->s2kparams == NULL) goto fail;
5555if(der_copy_octet_string((from)->s2kparams, (to)->s2kparams)) goto fail;
5556}else
5557(to)->s2kparams = NULL;
5558return 0;
5559fail:
5560free_ETYPE_INFO2_ENTRY(to);
5561return ENOMEM;
5562}
5563
5564int ASN1CALL
5565encode_ETYPE_INFO2(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ETYPE_INFO2 *data, size_t *size)
5566{
5567size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5568size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5569int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5570
5571for(i = (int)(data)->len - 1; i >= 0; --i) {
5572size_t Top_tag_for_oldret = ret;
5573ret = 0;
5574e = encode_ETYPE_INFO2_ENTRY(p, len, &(data)->val[i], &l);
5575if (e) return e;
5576p -= l; len -= l; ret += l;
5577
5578ret += Top_tag_for_oldret;
5579}
5580e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5581if (e) return e;
5582p -= l; len -= l; ret += l;
5583
5584*size = ret;
5585return 0;
5586}
5587
5588int ASN1CALL
5589decode_ETYPE_INFO2(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ETYPE_INFO2 *data, size_t *size)
5590{
5591size_t ret = 0;
5592size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5593int e HEIMDAL_UNUSED_ATTRIBUTE;
5594
5595memset(data, 0, sizeof(*data));
5596{
5597size_t Top_datalen, Top_oldlen;
5598Der_type Top_type;
5599e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5600if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5601if(e) goto fail;
5602p += l; len -= l; ret += l;
5603Top_oldlen = len;
5604if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5605len = Top_datalen;
5606{
5607size_t Top_Tag_origlen = len;
5608size_t Top_Tag_oldret = ret;
5609size_t Top_Tag_olen = 0;
5610void *Top_Tag_tmp;
5611ret = 0;
5612(data)->len = 0;
5613(data)->val = NULL;
5614while(ret < Top_Tag_origlen) {
5615size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
5616if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5617Top_Tag_olen = Top_Tag_nlen;
5618Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
5619if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5620(data)->val = Top_Tag_tmp;
5621e = decode_ETYPE_INFO2_ENTRY(p, len, &(data)->val[(data)->len], &l);
5622if(e) goto fail;
5623p += l; len -= l; ret += l;
5624(data)->len++;
5625len = Top_Tag_origlen - ret;
5626}
5627ret += Top_Tag_oldret;
5628}
5629if ((data)->len > 2147483647) {
5630e = ASN1_MAX_CONSTRAINT; goto fail;
5631}
5632if ((data)->len < 1) {
5633e = ASN1_MIN_CONSTRAINT; goto fail;
5634}
5635len = Top_oldlen - Top_datalen;
5636}
5637if(size) *size = ret;
5638return 0;
5639fail:
5640free_ETYPE_INFO2(data);
5641return e;
5642}
5643
5644void ASN1CALL
5645free_ETYPE_INFO2(ETYPE_INFO2 *data)
5646{
5647while((data)->len){
5648free_ETYPE_INFO2_ENTRY(&(data)->val[(data)->len-1]);
5649(data)->len--;
5650}
5651free((data)->val);
5652(data)->val = NULL;
5653}
5654
5655size_t ASN1CALL
5656length_ETYPE_INFO2(const ETYPE_INFO2 *data)
5657{
5658size_t ret = 0;
5659{
5660size_t Top_tag_oldret = ret;
5661unsigned int n_Top_tag;
5662ret = 0;
5663for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
5664size_t Top_tag_for_oldret = ret;
5665ret = 0;
5666ret += length_ETYPE_INFO2_ENTRY(&(data)->val[n_Top_tag - 1]);
5667ret += Top_tag_for_oldret;
5668}
5669ret += Top_tag_oldret;
5670}
5671ret += 1 + der_length_len (ret);
5672return ret;
5673}
5674
5675int ASN1CALL
5676copy_ETYPE_INFO2(const ETYPE_INFO2 *from, ETYPE_INFO2 *to)
5677{
5678memset(to, 0, sizeof(*to));
5679if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
5680goto fail;
5681for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
5682if(copy_ETYPE_INFO2_ENTRY(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
5683}
5684return 0;
5685fail:
5686free_ETYPE_INFO2(to);
5687return ENOMEM;
5688}
5689
5690int ASN1CALL
5691add_ETYPE_INFO2(ETYPE_INFO2 *data, const ETYPE_INFO2_ENTRY *element)
5692{
5693int ret;
5694void *ptr;
5695
5696ptr = realloc(data->val,
5697 (data->len + 1) * sizeof(data->val[0]));
5698if (ptr == NULL) return ENOMEM;
5699data->val = ptr;
5700
5701ret = copy_ETYPE_INFO2_ENTRY(element, &data->val[data->len]);
5702if (ret) return ret;
5703data->len++;
5704return 0;
5705}
5706
5707int ASN1CALL
5708remove_ETYPE_INFO2(ETYPE_INFO2 *data, unsigned int element)
5709{
5710void *ptr;
5711
5712if (data->len == 0 || element >= data->len)
5713 return ASN1_OVERRUN;
5714free_ETYPE_INFO2_ENTRY(&data->val[element]);
5715data->len--;
5716if (element < data->len)
5717 memmove(&data->val[element], &data->val[element + 1],
5718 sizeof(data->val[0]) * (data->len - element));
5719ptr = realloc(data->val, data->len * sizeof(data->val[0]));
5720if (ptr != NULL || data->len == 0) data->val = ptr;
5721return 0;
5722}
5723
5724int ASN1CALL
5725encode_METHOD_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const METHOD_DATA *data, size_t *size)
5726{
5727size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5728size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5729int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5730
5731for(i = (int)(data)->len - 1; i >= 0; --i) {
5732size_t Top_tag_for_oldret = ret;
5733ret = 0;
5734e = encode_PA_DATA(p, len, &(data)->val[i], &l);
5735if (e) return e;
5736p -= l; len -= l; ret += l;
5737
5738ret += Top_tag_for_oldret;
5739}
5740e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5741if (e) return e;
5742p -= l; len -= l; ret += l;
5743
5744*size = ret;
5745return 0;
5746}
5747
5748int ASN1CALL
5749decode_METHOD_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, METHOD_DATA *data, size_t *size)
5750{
5751size_t ret = 0;
5752size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5753int e HEIMDAL_UNUSED_ATTRIBUTE;
5754
5755memset(data, 0, sizeof(*data));
5756{
5757size_t Top_datalen, Top_oldlen;
5758Der_type Top_type;
5759e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5760if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5761if(e) goto fail;
5762p += l; len -= l; ret += l;
5763Top_oldlen = len;
5764if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5765len = Top_datalen;
5766{
5767size_t Top_Tag_origlen = len;
5768size_t Top_Tag_oldret = ret;
5769size_t Top_Tag_olen = 0;
5770void *Top_Tag_tmp;
5771ret = 0;
5772(data)->len = 0;
5773(data)->val = NULL;
5774while(ret < Top_Tag_origlen) {
5775size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
5776if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
5777Top_Tag_olen = Top_Tag_nlen;
5778Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
5779if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
5780(data)->val = Top_Tag_tmp;
5781e = decode_PA_DATA(p, len, &(data)->val[(data)->len], &l);
5782if(e) goto fail;
5783p += l; len -= l; ret += l;
5784(data)->len++;
5785len = Top_Tag_origlen - ret;
5786}
5787ret += Top_Tag_oldret;
5788}
5789len = Top_oldlen - Top_datalen;
5790}
5791if(size) *size = ret;
5792return 0;
5793fail:
5794free_METHOD_DATA(data);
5795return e;
5796}
5797
5798void ASN1CALL
5799free_METHOD_DATA(METHOD_DATA *data)
5800{
5801while((data)->len){
5802free_PA_DATA(&(data)->val[(data)->len-1]);
5803(data)->len--;
5804}
5805free((data)->val);
5806(data)->val = NULL;
5807}
5808
5809size_t ASN1CALL
5810length_METHOD_DATA(const METHOD_DATA *data)
5811{
5812size_t ret = 0;
5813{
5814size_t Top_tag_oldret = ret;
5815unsigned int n_Top_tag;
5816ret = 0;
5817for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
5818size_t Top_tag_for_oldret = ret;
5819ret = 0;
5820ret += length_PA_DATA(&(data)->val[n_Top_tag - 1]);
5821ret += Top_tag_for_oldret;
5822}
5823ret += Top_tag_oldret;
5824}
5825ret += 1 + der_length_len (ret);
5826return ret;
5827}
5828
5829int ASN1CALL
5830copy_METHOD_DATA(const METHOD_DATA *from, METHOD_DATA *to)
5831{
5832memset(to, 0, sizeof(*to));
5833if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
5834goto fail;
5835for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
5836if(copy_PA_DATA(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
5837}
5838return 0;
5839fail:
5840free_METHOD_DATA(to);
5841return ENOMEM;
5842}
5843
5844int ASN1CALL
5845add_METHOD_DATA(METHOD_DATA *data, const PA_DATA *element)
5846{
5847int ret;
5848void *ptr;
5849
5850ptr = realloc(data->val,
5851 (data->len + 1) * sizeof(data->val[0]));
5852if (ptr == NULL) return ENOMEM;
5853data->val = ptr;
5854
5855ret = copy_PA_DATA(element, &data->val[data->len]);
5856if (ret) return ret;
5857data->len++;
5858return 0;
5859}
5860
5861int ASN1CALL
5862remove_METHOD_DATA(METHOD_DATA *data, unsigned int element)
5863{
5864void *ptr;
5865
5866if (data->len == 0 || element >= data->len)
5867 return ASN1_OVERRUN;
5868free_PA_DATA(&data->val[element]);
5869data->len--;
5870if (element < data->len)
5871 memmove(&data->val[element], &data->val[element + 1],
5872 sizeof(data->val[0]) * (data->len - element));
5873ptr = realloc(data->val, data->len * sizeof(data->val[0]));
5874if (ptr != NULL || data->len == 0) data->val = ptr;
5875return 0;
5876}
5877
5878int ASN1CALL
5879encode_TypedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TypedData *data, size_t *size)
5880{
5881size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
5882size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5883int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
5884
5885/* data-value */
5886if((data)->data_value) {
5887size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5888ret = 0;
5889e = der_put_octet_string(p, len, (data)->data_value, &l);
5890if (e) return e;
5891p -= l; len -= l; ret += l;
5892
5893e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
5894if (e) return e;
5895p -= l; len -= l; ret += l;
5896
5897e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
5898if (e) return e;
5899p -= l; len -= l; ret += l;
5900
5901ret += Top_tag_oldret;
5902}
5903/* data-type */
5904{
5905size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
5906ret = 0;
5907e = encode_krb5int32(p, len, &(data)->data_type, &l);
5908if (e) return e;
5909p -= l; len -= l; ret += l;
5910
5911e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
5912if (e) return e;
5913p -= l; len -= l; ret += l;
5914
5915ret += Top_tag_oldret;
5916}
5917e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
5918if (e) return e;
5919p -= l; len -= l; ret += l;
5920
5921*size = ret;
5922return 0;
5923}
5924
5925int ASN1CALL
5926decode_TypedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TypedData *data, size_t *size)
5927{
5928size_t ret = 0;
5929size_t l HEIMDAL_UNUSED_ATTRIBUTE;
5930int e HEIMDAL_UNUSED_ATTRIBUTE;
5931
5932memset(data, 0, sizeof(*data));
5933{
5934size_t Top_datalen, Top_oldlen;
5935Der_type Top_type;
5936e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
5937if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
5938if(e) goto fail;
5939p += l; len -= l; ret += l;
5940Top_oldlen = len;
5941if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5942len = Top_datalen;
5943{
5944size_t data_type_datalen, data_type_oldlen;
5945Der_type data_type_type;
5946e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &data_type_type, 0, &data_type_datalen, &l);
5947if (e == 0 && data_type_type != CONS) { e = ASN1_BAD_ID; }
5948if(e) goto fail;
5949p += l; len -= l; ret += l;
5950data_type_oldlen = len;
5951if (data_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5952len = data_type_datalen;
5953e = decode_krb5int32(p, len, &(data)->data_type, &l);
5954if(e) goto fail;
5955p += l; len -= l; ret += l;
5956len = data_type_oldlen - data_type_datalen;
5957}
5958{
5959size_t data_value_datalen, data_value_oldlen;
5960Der_type data_value_type;
5961e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &data_value_type, 1, &data_value_datalen, &l);
5962if (e == 0 && data_value_type != CONS) { e = ASN1_BAD_ID; }
5963if(e) {
5964(data)->data_value = NULL;
5965} else {
5966(data)->data_value = calloc(1, sizeof(*(data)->data_value));
5967if ((data)->data_value == NULL) { e = ENOMEM; goto fail; }
5968p += l; len -= l; ret += l;
5969data_value_oldlen = len;
5970if (data_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5971len = data_value_datalen;
5972{
5973size_t data_value_Tag_datalen, data_value_Tag_oldlen;
5974Der_type data_value_Tag_type;
5975e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &data_value_Tag_type, UT_OctetString, &data_value_Tag_datalen, &l);
5976if (e == 0 && data_value_Tag_type != PRIM) { e = ASN1_BAD_ID; }
5977if(e) goto fail;
5978p += l; len -= l; ret += l;
5979data_value_Tag_oldlen = len;
5980if (data_value_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
5981len = data_value_Tag_datalen;
5982e = der_get_octet_string(p, len, (data)->data_value, &l);
5983if(e) goto fail;
5984p += l; len -= l; ret += l;
5985len = data_value_Tag_oldlen - data_value_Tag_datalen;
5986}
5987len = data_value_oldlen - data_value_datalen;
5988}
5989}
5990len = Top_oldlen - Top_datalen;
5991}
5992if(size) *size = ret;
5993return 0;
5994fail:
5995free_TypedData(data);
5996return e;
5997}
5998
5999void ASN1CALL
6000free_TypedData(TypedData *data)
6001{
6002free_krb5int32(&(data)->data_type);
6003if((data)->data_value) {
6004der_free_octet_string((data)->data_value);
6005free((data)->data_value);
6006(data)->data_value = NULL;
6007}
6008}
6009
6010size_t ASN1CALL
6011length_TypedData(const TypedData *data)
6012{
6013size_t ret = 0;
6014{
6015size_t Top_tag_oldret = ret;
6016ret = 0;
6017ret += length_krb5int32(&(data)->data_type);
6018ret += 1 + der_length_len (ret);
6019ret += Top_tag_oldret;
6020}
6021if((data)->data_value){
6022size_t Top_tag_oldret = ret;
6023ret = 0;
6024ret += der_length_octet_string((data)->data_value);
6025ret += 1 + der_length_len (ret);
6026ret += 1 + der_length_len (ret);
6027ret += Top_tag_oldret;
6028}
6029ret += 1 + der_length_len (ret);
6030return ret;
6031}
6032
6033int ASN1CALL
6034copy_TypedData(const TypedData *from, TypedData *to)
6035{
6036memset(to, 0, sizeof(*to));
6037if(copy_krb5int32(&(from)->data_type, &(to)->data_type)) goto fail;
6038if((from)->data_value) {
6039(to)->data_value = malloc(sizeof(*(to)->data_value));
6040if((to)->data_value == NULL) goto fail;
6041if(der_copy_octet_string((from)->data_value, (to)->data_value)) goto fail;
6042}else
6043(to)->data_value = NULL;
6044return 0;
6045fail:
6046free_TypedData(to);
6047return ENOMEM;
6048}
6049
6050int ASN1CALL
6051encode_TYPED_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TYPED_DATA *data, size_t *size)
6052{
6053size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6054size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6055int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6056
6057for(i = (int)(data)->len - 1; i >= 0; --i) {
6058size_t Top_tag_for_oldret = ret;
6059ret = 0;
6060e = encode_TypedData(p, len, &(data)->val[i], &l);
6061if (e) return e;
6062p -= l; len -= l; ret += l;
6063
6064ret += Top_tag_for_oldret;
6065}
6066e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6067if (e) return e;
6068p -= l; len -= l; ret += l;
6069
6070*size = ret;
6071return 0;
6072}
6073
6074int ASN1CALL
6075decode_TYPED_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TYPED_DATA *data, size_t *size)
6076{
6077size_t ret = 0;
6078size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6079int e HEIMDAL_UNUSED_ATTRIBUTE;
6080
6081memset(data, 0, sizeof(*data));
6082{
6083size_t Top_datalen, Top_oldlen;
6084Der_type Top_type;
6085e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
6086if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
6087if(e) goto fail;
6088p += l; len -= l; ret += l;
6089Top_oldlen = len;
6090if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6091len = Top_datalen;
6092{
6093size_t Top_Tag_origlen = len;
6094size_t Top_Tag_oldret = ret;
6095size_t Top_Tag_olen = 0;
6096void *Top_Tag_tmp;
6097ret = 0;
6098(data)->len = 0;
6099(data)->val = NULL;
6100while(ret < Top_Tag_origlen) {
6101size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
6102if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6103Top_Tag_olen = Top_Tag_nlen;
6104Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
6105if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6106(data)->val = Top_Tag_tmp;
6107e = decode_TypedData(p, len, &(data)->val[(data)->len], &l);
6108if(e) goto fail;
6109p += l; len -= l; ret += l;
6110(data)->len++;
6111len = Top_Tag_origlen - ret;
6112}
6113ret += Top_Tag_oldret;
6114}
6115if ((data)->len > 2147483647) {
6116e = ASN1_MAX_CONSTRAINT; goto fail;
6117}
6118if ((data)->len < 1) {
6119e = ASN1_MIN_CONSTRAINT; goto fail;
6120}
6121len = Top_oldlen - Top_datalen;
6122}
6123if(size) *size = ret;
6124return 0;
6125fail:
6126free_TYPED_DATA(data);
6127return e;
6128}
6129
6130void ASN1CALL
6131free_TYPED_DATA(TYPED_DATA *data)
6132{
6133while((data)->len){
6134free_TypedData(&(data)->val[(data)->len-1]);
6135(data)->len--;
6136}
6137free((data)->val);
6138(data)->val = NULL;
6139}
6140
6141size_t ASN1CALL
6142length_TYPED_DATA(const TYPED_DATA *data)
6143{
6144size_t ret = 0;
6145{
6146size_t Top_tag_oldret = ret;
6147unsigned int n_Top_tag;
6148ret = 0;
6149for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
6150size_t Top_tag_for_oldret = ret;
6151ret = 0;
6152ret += length_TypedData(&(data)->val[n_Top_tag - 1]);
6153ret += Top_tag_for_oldret;
6154}
6155ret += Top_tag_oldret;
6156}
6157ret += 1 + der_length_len (ret);
6158return ret;
6159}
6160
6161int ASN1CALL
6162copy_TYPED_DATA(const TYPED_DATA *from, TYPED_DATA *to)
6163{
6164memset(to, 0, sizeof(*to));
6165if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
6166goto fail;
6167for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
6168if(copy_TypedData(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
6169}
6170return 0;
6171fail:
6172free_TYPED_DATA(to);
6173return ENOMEM;
6174}
6175
6176int ASN1CALL
6177encode_KDC_REQ_BODY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDC_REQ_BODY *data, size_t *size)
6178{
6179size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6180size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6181int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6182
6183/* additional-tickets */
6184if((data)->additional_tickets) {
6185size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6186ret = 0;
6187for(i = (int)((data)->additional_tickets)->len - 1; i >= 0; --i) {
6188size_t additional_tickets_tag_tag_for_oldret = ret;
6189ret = 0;
6190e = encode_Ticket(p, len, &((data)->additional_tickets)->val[i], &l);
6191if (e) return e;
6192p -= l; len -= l; ret += l;
6193
6194ret += additional_tickets_tag_tag_for_oldret;
6195}
6196e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6197if (e) return e;
6198p -= l; len -= l; ret += l;
6199
6200e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
6201if (e) return e;
6202p -= l; len -= l; ret += l;
6203
6204ret += Top_tag_oldret;
6205}
6206/* enc-authorization-data */
6207if((data)->enc_authorization_data) {
6208size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6209ret = 0;
6210e = encode_EncryptedData(p, len, (data)->enc_authorization_data, &l);
6211if (e) return e;
6212p -= l; len -= l; ret += l;
6213
6214e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
6215if (e) return e;
6216p -= l; len -= l; ret += l;
6217
6218ret += Top_tag_oldret;
6219}
6220/* addresses */
6221if((data)->addresses) {
6222size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6223ret = 0;
6224e = encode_HostAddresses(p, len, (data)->addresses, &l);
6225if (e) return e;
6226p -= l; len -= l; ret += l;
6227
6228e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
6229if (e) return e;
6230p -= l; len -= l; ret += l;
6231
6232ret += Top_tag_oldret;
6233}
6234/* etype */
6235{
6236size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6237ret = 0;
6238for(i = (int)(&(data)->etype)->len - 1; i >= 0; --i) {
6239size_t etype_tag_tag_for_oldret = ret;
6240ret = 0;
6241e = encode_ENCTYPE(p, len, &(&(data)->etype)->val[i], &l);
6242if (e) return e;
6243p -= l; len -= l; ret += l;
6244
6245ret += etype_tag_tag_for_oldret;
6246}
6247e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6248if (e) return e;
6249p -= l; len -= l; ret += l;
6250
6251e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
6252if (e) return e;
6253p -= l; len -= l; ret += l;
6254
6255ret += Top_tag_oldret;
6256}
6257/* nonce */
6258{
6259size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6260ret = 0;
6261e = encode_krb5int32(p, len, &(data)->nonce, &l);
6262if (e) return e;
6263p -= l; len -= l; ret += l;
6264
6265e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
6266if (e) return e;
6267p -= l; len -= l; ret += l;
6268
6269ret += Top_tag_oldret;
6270}
6271/* rtime */
6272if((data)->rtime) {
6273size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6274ret = 0;
6275e = encode_KerberosTime(p, len, (data)->rtime, &l);
6276if (e) return e;
6277p -= l; len -= l; ret += l;
6278
6279e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
6280if (e) return e;
6281p -= l; len -= l; ret += l;
6282
6283ret += Top_tag_oldret;
6284}
6285/* till */
6286if((data)->till) {
6287size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6288ret = 0;
6289e = encode_KerberosTime(p, len, (data)->till, &l);
6290if (e) return e;
6291p -= l; len -= l; ret += l;
6292
6293e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
6294if (e) return e;
6295p -= l; len -= l; ret += l;
6296
6297ret += Top_tag_oldret;
6298}
6299/* from */
6300if((data)->from) {
6301size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6302ret = 0;
6303e = encode_KerberosTime(p, len, (data)->from, &l);
6304if (e) return e;
6305p -= l; len -= l; ret += l;
6306
6307e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
6308if (e) return e;
6309p -= l; len -= l; ret += l;
6310
6311ret += Top_tag_oldret;
6312}
6313/* sname */
6314if((data)->sname) {
6315size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6316ret = 0;
6317e = encode_PrincipalName(p, len, (data)->sname, &l);
6318if (e) return e;
6319p -= l; len -= l; ret += l;
6320
6321e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
6322if (e) return e;
6323p -= l; len -= l; ret += l;
6324
6325ret += Top_tag_oldret;
6326}
6327/* realm */
6328{
6329size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6330ret = 0;
6331e = encode_Realm(p, len, &(data)->realm, &l);
6332if (e) return e;
6333p -= l; len -= l; ret += l;
6334
6335e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
6336if (e) return e;
6337p -= l; len -= l; ret += l;
6338
6339ret += Top_tag_oldret;
6340}
6341/* cname */
6342if((data)->cname) {
6343size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6344ret = 0;
6345e = encode_PrincipalName(p, len, (data)->cname, &l);
6346if (e) return e;
6347p -= l; len -= l; ret += l;
6348
6349e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
6350if (e) return e;
6351p -= l; len -= l; ret += l;
6352
6353ret += Top_tag_oldret;
6354}
6355/* kdc-options */
6356{
6357size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6358ret = 0;
6359e = encode_KDCOptions(p, len, &(data)->kdc_options, &l);
6360if (e) return e;
6361p -= l; len -= l; ret += l;
6362
6363e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
6364if (e) return e;
6365p -= l; len -= l; ret += l;
6366
6367ret += Top_tag_oldret;
6368}
6369e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6370if (e) return e;
6371p -= l; len -= l; ret += l;
6372
6373*size = ret;
6374return 0;
6375}
6376
6377int ASN1CALL
6378decode_KDC_REQ_BODY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDC_REQ_BODY *data, size_t *size)
6379{
6380size_t ret = 0;
6381size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6382int e HEIMDAL_UNUSED_ATTRIBUTE;
6383
6384memset(data, 0, sizeof(*data));
6385{
6386size_t Top_datalen, Top_oldlen;
6387Der_type Top_type;
6388e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
6389if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
6390if(e) goto fail;
6391p += l; len -= l; ret += l;
6392Top_oldlen = len;
6393if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6394len = Top_datalen;
6395{
6396size_t kdc_options_datalen, kdc_options_oldlen;
6397Der_type kdc_options_type;
6398e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kdc_options_type, 0, &kdc_options_datalen, &l);
6399if (e == 0 && kdc_options_type != CONS) { e = ASN1_BAD_ID; }
6400if(e) goto fail;
6401p += l; len -= l; ret += l;
6402kdc_options_oldlen = len;
6403if (kdc_options_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6404len = kdc_options_datalen;
6405e = decode_KDCOptions(p, len, &(data)->kdc_options, &l);
6406if(e) goto fail;
6407p += l; len -= l; ret += l;
6408len = kdc_options_oldlen - kdc_options_datalen;
6409}
6410{
6411size_t cname_datalen, cname_oldlen;
6412Der_type cname_type;
6413e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 1, &cname_datalen, &l);
6414if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
6415if(e) {
6416(data)->cname = NULL;
6417} else {
6418(data)->cname = calloc(1, sizeof(*(data)->cname));
6419if ((data)->cname == NULL) { e = ENOMEM; goto fail; }
6420p += l; len -= l; ret += l;
6421cname_oldlen = len;
6422if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6423len = cname_datalen;
6424e = decode_PrincipalName(p, len, (data)->cname, &l);
6425if(e) goto fail;
6426p += l; len -= l; ret += l;
6427len = cname_oldlen - cname_datalen;
6428}
6429}
6430{
6431size_t realm_datalen, realm_oldlen;
6432Der_type realm_type;
6433e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 2, &realm_datalen, &l);
6434if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
6435if(e) goto fail;
6436p += l; len -= l; ret += l;
6437realm_oldlen = len;
6438if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6439len = realm_datalen;
6440e = decode_Realm(p, len, &(data)->realm, &l);
6441if(e) goto fail;
6442p += l; len -= l; ret += l;
6443len = realm_oldlen - realm_datalen;
6444}
6445{
6446size_t sname_datalen, sname_oldlen;
6447Der_type sname_type;
6448e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 3, &sname_datalen, &l);
6449if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
6450if(e) {
6451(data)->sname = NULL;
6452} else {
6453(data)->sname = calloc(1, sizeof(*(data)->sname));
6454if ((data)->sname == NULL) { e = ENOMEM; goto fail; }
6455p += l; len -= l; ret += l;
6456sname_oldlen = len;
6457if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6458len = sname_datalen;
6459e = decode_PrincipalName(p, len, (data)->sname, &l);
6460if(e) goto fail;
6461p += l; len -= l; ret += l;
6462len = sname_oldlen - sname_datalen;
6463}
6464}
6465{
6466size_t from_datalen, from_oldlen;
6467Der_type from_type;
6468e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &from_type, 4, &from_datalen, &l);
6469if (e == 0 && from_type != CONS) { e = ASN1_BAD_ID; }
6470if(e) {
6471(data)->from = NULL;
6472} else {
6473(data)->from = calloc(1, sizeof(*(data)->from));
6474if ((data)->from == NULL) { e = ENOMEM; goto fail; }
6475p += l; len -= l; ret += l;
6476from_oldlen = len;
6477if (from_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6478len = from_datalen;
6479e = decode_KerberosTime(p, len, (data)->from, &l);
6480if(e) goto fail;
6481p += l; len -= l; ret += l;
6482len = from_oldlen - from_datalen;
6483}
6484}
6485{
6486size_t till_datalen, till_oldlen;
6487Der_type till_type;
6488e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &till_type, 5, &till_datalen, &l);
6489if (e == 0 && till_type != CONS) { e = ASN1_BAD_ID; }
6490if(e) {
6491(data)->till = NULL;
6492} else {
6493(data)->till = calloc(1, sizeof(*(data)->till));
6494if ((data)->till == NULL) { e = ENOMEM; goto fail; }
6495p += l; len -= l; ret += l;
6496till_oldlen = len;
6497if (till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6498len = till_datalen;
6499e = decode_KerberosTime(p, len, (data)->till, &l);
6500if(e) goto fail;
6501p += l; len -= l; ret += l;
6502len = till_oldlen - till_datalen;
6503}
6504}
6505{
6506size_t rtime_datalen, rtime_oldlen;
6507Der_type rtime_type;
6508e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &rtime_type, 6, &rtime_datalen, &l);
6509if (e == 0 && rtime_type != CONS) { e = ASN1_BAD_ID; }
6510if(e) {
6511(data)->rtime = NULL;
6512} else {
6513(data)->rtime = calloc(1, sizeof(*(data)->rtime));
6514if ((data)->rtime == NULL) { e = ENOMEM; goto fail; }
6515p += l; len -= l; ret += l;
6516rtime_oldlen = len;
6517if (rtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6518len = rtime_datalen;
6519e = decode_KerberosTime(p, len, (data)->rtime, &l);
6520if(e) goto fail;
6521p += l; len -= l; ret += l;
6522len = rtime_oldlen - rtime_datalen;
6523}
6524}
6525{
6526size_t nonce_datalen, nonce_oldlen;
6527Der_type nonce_type;
6528e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonce_type, 7, &nonce_datalen, &l);
6529if (e == 0 && nonce_type != CONS) { e = ASN1_BAD_ID; }
6530if(e) goto fail;
6531p += l; len -= l; ret += l;
6532nonce_oldlen = len;
6533if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6534len = nonce_datalen;
6535e = decode_krb5int32(p, len, &(data)->nonce, &l);
6536if(e) goto fail;
6537p += l; len -= l; ret += l;
6538len = nonce_oldlen - nonce_datalen;
6539}
6540{
6541size_t etype_datalen, etype_oldlen;
6542Der_type etype_type;
6543e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 8, &etype_datalen, &l);
6544if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
6545if(e) goto fail;
6546p += l; len -= l; ret += l;
6547etype_oldlen = len;
6548if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6549len = etype_datalen;
6550{
6551size_t etype_Tag_datalen, etype_Tag_oldlen;
6552Der_type etype_Tag_type;
6553e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &etype_Tag_type, UT_Sequence, &etype_Tag_datalen, &l);
6554if (e == 0 && etype_Tag_type != CONS) { e = ASN1_BAD_ID; }
6555if(e) goto fail;
6556p += l; len -= l; ret += l;
6557etype_Tag_oldlen = len;
6558if (etype_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6559len = etype_Tag_datalen;
6560{
6561size_t etype_Tag_Tag_origlen = len;
6562size_t etype_Tag_Tag_oldret = ret;
6563size_t etype_Tag_Tag_olen = 0;
6564void *etype_Tag_Tag_tmp;
6565ret = 0;
6566(&(data)->etype)->len = 0;
6567(&(data)->etype)->val = NULL;
6568while(ret < etype_Tag_Tag_origlen) {
6569size_t etype_Tag_Tag_nlen = etype_Tag_Tag_olen + sizeof(*((&(data)->etype)->val));
6570if (etype_Tag_Tag_olen > etype_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6571etype_Tag_Tag_olen = etype_Tag_Tag_nlen;
6572etype_Tag_Tag_tmp = realloc((&(data)->etype)->val, etype_Tag_Tag_olen);
6573if (etype_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6574(&(data)->etype)->val = etype_Tag_Tag_tmp;
6575e = decode_ENCTYPE(p, len, &(&(data)->etype)->val[(&(data)->etype)->len], &l);
6576if(e) goto fail;
6577p += l; len -= l; ret += l;
6578(&(data)->etype)->len++;
6579len = etype_Tag_Tag_origlen - ret;
6580}
6581ret += etype_Tag_Tag_oldret;
6582}
6583len = etype_Tag_oldlen - etype_Tag_datalen;
6584}
6585len = etype_oldlen - etype_datalen;
6586}
6587{
6588size_t addresses_datalen, addresses_oldlen;
6589Der_type addresses_type;
6590e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &addresses_type, 9, &addresses_datalen, &l);
6591if (e == 0 && addresses_type != CONS) { e = ASN1_BAD_ID; }
6592if(e) {
6593(data)->addresses = NULL;
6594} else {
6595(data)->addresses = calloc(1, sizeof(*(data)->addresses));
6596if ((data)->addresses == NULL) { e = ENOMEM; goto fail; }
6597p += l; len -= l; ret += l;
6598addresses_oldlen = len;
6599if (addresses_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6600len = addresses_datalen;
6601e = decode_HostAddresses(p, len, (data)->addresses, &l);
6602if(e) goto fail;
6603p += l; len -= l; ret += l;
6604len = addresses_oldlen - addresses_datalen;
6605}
6606}
6607{
6608size_t enc_authorization_data_datalen, enc_authorization_data_oldlen;
6609Der_type enc_authorization_data_type;
6610e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_authorization_data_type, 10, &enc_authorization_data_datalen, &l);
6611if (e == 0 && enc_authorization_data_type != CONS) { e = ASN1_BAD_ID; }
6612if(e) {
6613(data)->enc_authorization_data = NULL;
6614} else {
6615(data)->enc_authorization_data = calloc(1, sizeof(*(data)->enc_authorization_data));
6616if ((data)->enc_authorization_data == NULL) { e = ENOMEM; goto fail; }
6617p += l; len -= l; ret += l;
6618enc_authorization_data_oldlen = len;
6619if (enc_authorization_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6620len = enc_authorization_data_datalen;
6621e = decode_EncryptedData(p, len, (data)->enc_authorization_data, &l);
6622if(e) goto fail;
6623p += l; len -= l; ret += l;
6624len = enc_authorization_data_oldlen - enc_authorization_data_datalen;
6625}
6626}
6627{
6628size_t additional_tickets_datalen, additional_tickets_oldlen;
6629Der_type additional_tickets_type;
6630e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &additional_tickets_type, 11, &additional_tickets_datalen, &l);
6631if (e == 0 && additional_tickets_type != CONS) { e = ASN1_BAD_ID; }
6632if(e) {
6633(data)->additional_tickets = NULL;
6634} else {
6635(data)->additional_tickets = calloc(1, sizeof(*(data)->additional_tickets));
6636if ((data)->additional_tickets == NULL) { e = ENOMEM; goto fail; }
6637p += l; len -= l; ret += l;
6638additional_tickets_oldlen = len;
6639if (additional_tickets_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6640len = additional_tickets_datalen;
6641{
6642size_t additional_tickets_Tag_datalen, additional_tickets_Tag_oldlen;
6643Der_type additional_tickets_Tag_type;
6644e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &additional_tickets_Tag_type, UT_Sequence, &additional_tickets_Tag_datalen, &l);
6645if (e == 0 && additional_tickets_Tag_type != CONS) { e = ASN1_BAD_ID; }
6646if(e) goto fail;
6647p += l; len -= l; ret += l;
6648additional_tickets_Tag_oldlen = len;
6649if (additional_tickets_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
6650len = additional_tickets_Tag_datalen;
6651{
6652size_t additional_tickets_Tag_Tag_origlen = len;
6653size_t additional_tickets_Tag_Tag_oldret = ret;
6654size_t additional_tickets_Tag_Tag_olen = 0;
6655void *additional_tickets_Tag_Tag_tmp;
6656ret = 0;
6657((data)->additional_tickets)->len = 0;
6658((data)->additional_tickets)->val = NULL;
6659while(ret < additional_tickets_Tag_Tag_origlen) {
6660size_t additional_tickets_Tag_Tag_nlen = additional_tickets_Tag_Tag_olen + sizeof(*(((data)->additional_tickets)->val));
6661if (additional_tickets_Tag_Tag_olen > additional_tickets_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
6662additional_tickets_Tag_Tag_olen = additional_tickets_Tag_Tag_nlen;
6663additional_tickets_Tag_Tag_tmp = realloc(((data)->additional_tickets)->val, additional_tickets_Tag_Tag_olen);
6664if (additional_tickets_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
6665((data)->additional_tickets)->val = additional_tickets_Tag_Tag_tmp;
6666e = decode_Ticket(p, len, &((data)->additional_tickets)->val[((data)->additional_tickets)->len], &l);
6667if(e) goto fail;
6668p += l; len -= l; ret += l;
6669((data)->additional_tickets)->len++;
6670len = additional_tickets_Tag_Tag_origlen - ret;
6671}
6672ret += additional_tickets_Tag_Tag_oldret;
6673}
6674len = additional_tickets_Tag_oldlen - additional_tickets_Tag_datalen;
6675}
6676len = additional_tickets_oldlen - additional_tickets_datalen;
6677}
6678}
6679len = Top_oldlen - Top_datalen;
6680}
6681if(size) *size = ret;
6682return 0;
6683fail:
6684free_KDC_REQ_BODY(data);
6685return e;
6686}
6687
6688void ASN1CALL
6689free_KDC_REQ_BODY(KDC_REQ_BODY *data)
6690{
6691free_KDCOptions(&(data)->kdc_options);
6692if((data)->cname) {
6693free_PrincipalName((data)->cname);
6694free((data)->cname);
6695(data)->cname = NULL;
6696}
6697free_Realm(&(data)->realm);
6698if((data)->sname) {
6699free_PrincipalName((data)->sname);
6700free((data)->sname);
6701(data)->sname = NULL;
6702}
6703if((data)->from) {
6704free_KerberosTime((data)->from);
6705free((data)->from);
6706(data)->from = NULL;
6707}
6708if((data)->till) {
6709free_KerberosTime((data)->till);
6710free((data)->till);
6711(data)->till = NULL;
6712}
6713if((data)->rtime) {
6714free_KerberosTime((data)->rtime);
6715free((data)->rtime);
6716(data)->rtime = NULL;
6717}
6718free_krb5int32(&(data)->nonce);
6719while((&(data)->etype)->len){
6720free_ENCTYPE(&(&(data)->etype)->val[(&(data)->etype)->len-1]);
6721(&(data)->etype)->len--;
6722}
6723free((&(data)->etype)->val);
6724(&(data)->etype)->val = NULL;
6725if((data)->addresses) {
6726free_HostAddresses((data)->addresses);
6727free((data)->addresses);
6728(data)->addresses = NULL;
6729}
6730if((data)->enc_authorization_data) {
6731free_EncryptedData((data)->enc_authorization_data);
6732free((data)->enc_authorization_data);
6733(data)->enc_authorization_data = NULL;
6734}
6735if((data)->additional_tickets) {
6736while(((data)->additional_tickets)->len){
6737free_Ticket(&((data)->additional_tickets)->val[((data)->additional_tickets)->len-1]);
6738((data)->additional_tickets)->len--;
6739}
6740free(((data)->additional_tickets)->val);
6741((data)->additional_tickets)->val = NULL;
6742free((data)->additional_tickets);
6743(data)->additional_tickets = NULL;
6744}
6745}
6746
6747size_t ASN1CALL
6748length_KDC_REQ_BODY(const KDC_REQ_BODY *data)
6749{
6750size_t ret = 0;
6751{
6752size_t Top_tag_oldret = ret;
6753ret = 0;
6754ret += length_KDCOptions(&(data)->kdc_options);
6755ret += 1 + der_length_len (ret);
6756ret += Top_tag_oldret;
6757}
6758if((data)->cname){
6759size_t Top_tag_oldret = ret;
6760ret = 0;
6761ret += length_PrincipalName((data)->cname);
6762ret += 1 + der_length_len (ret);
6763ret += Top_tag_oldret;
6764}
6765{
6766size_t Top_tag_oldret = ret;
6767ret = 0;
6768ret += length_Realm(&(data)->realm);
6769ret += 1 + der_length_len (ret);
6770ret += Top_tag_oldret;
6771}
6772if((data)->sname){
6773size_t Top_tag_oldret = ret;
6774ret = 0;
6775ret += length_PrincipalName((data)->sname);
6776ret += 1 + der_length_len (ret);
6777ret += Top_tag_oldret;
6778}
6779if((data)->from){
6780size_t Top_tag_oldret = ret;
6781ret = 0;
6782ret += length_KerberosTime((data)->from);
6783ret += 1 + der_length_len (ret);
6784ret += Top_tag_oldret;
6785}
6786if((data)->till){
6787size_t Top_tag_oldret = ret;
6788ret = 0;
6789ret += length_KerberosTime((data)->till);
6790ret += 1 + der_length_len (ret);
6791ret += Top_tag_oldret;
6792}
6793if((data)->rtime){
6794size_t Top_tag_oldret = ret;
6795ret = 0;
6796ret += length_KerberosTime((data)->rtime);
6797ret += 1 + der_length_len (ret);
6798ret += Top_tag_oldret;
6799}
6800{
6801size_t Top_tag_oldret = ret;
6802ret = 0;
6803ret += length_krb5int32(&(data)->nonce);
6804ret += 1 + der_length_len (ret);
6805ret += Top_tag_oldret;
6806}
6807{
6808size_t Top_tag_oldret = ret;
6809ret = 0;
6810{
6811size_t etype_tag_tag_oldret = ret;
6812unsigned int n_etype_tag_tag;
6813ret = 0;
6814for(n_etype_tag_tag = (&(data)->etype)->len; n_etype_tag_tag > 0; --n_etype_tag_tag){
6815size_t etype_tag_tag_for_oldret = ret;
6816ret = 0;
6817ret += length_ENCTYPE(&(&(data)->etype)->val[n_etype_tag_tag - 1]);
6818ret += etype_tag_tag_for_oldret;
6819}
6820ret += etype_tag_tag_oldret;
6821}
6822ret += 1 + der_length_len (ret);
6823ret += 1 + der_length_len (ret);
6824ret += Top_tag_oldret;
6825}
6826if((data)->addresses){
6827size_t Top_tag_oldret = ret;
6828ret = 0;
6829ret += length_HostAddresses((data)->addresses);
6830ret += 1 + der_length_len (ret);
6831ret += Top_tag_oldret;
6832}
6833if((data)->enc_authorization_data){
6834size_t Top_tag_oldret = ret;
6835ret = 0;
6836ret += length_EncryptedData((data)->enc_authorization_data);
6837ret += 1 + der_length_len (ret);
6838ret += Top_tag_oldret;
6839}
6840if((data)->additional_tickets){
6841size_t Top_tag_oldret = ret;
6842ret = 0;
6843{
6844size_t additional_tickets_tag_tag_oldret = ret;
6845unsigned int n_additional_tickets_tag_tag;
6846ret = 0;
6847for(n_additional_tickets_tag_tag = ((data)->additional_tickets)->len; n_additional_tickets_tag_tag > 0; --n_additional_tickets_tag_tag){
6848size_t additional_tickets_tag_tag_for_oldret = ret;
6849ret = 0;
6850ret += length_Ticket(&((data)->additional_tickets)->val[n_additional_tickets_tag_tag - 1]);
6851ret += additional_tickets_tag_tag_for_oldret;
6852}
6853ret += additional_tickets_tag_tag_oldret;
6854}
6855ret += 1 + der_length_len (ret);
6856ret += 1 + der_length_len (ret);
6857ret += Top_tag_oldret;
6858}
6859ret += 1 + der_length_len (ret);
6860return ret;
6861}
6862
6863int ASN1CALL
6864copy_KDC_REQ_BODY(const KDC_REQ_BODY *from, KDC_REQ_BODY *to)
6865{
6866memset(to, 0, sizeof(*to));
6867if(copy_KDCOptions(&(from)->kdc_options, &(to)->kdc_options)) goto fail;
6868if((from)->cname) {
6869(to)->cname = malloc(sizeof(*(to)->cname));
6870if((to)->cname == NULL) goto fail;
6871if(copy_PrincipalName((from)->cname, (to)->cname)) goto fail;
6872}else
6873(to)->cname = NULL;
6874if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
6875if((from)->sname) {
6876(to)->sname = malloc(sizeof(*(to)->sname));
6877if((to)->sname == NULL) goto fail;
6878if(copy_PrincipalName((from)->sname, (to)->sname)) goto fail;
6879}else
6880(to)->sname = NULL;
6881if((from)->from) {
6882(to)->from = malloc(sizeof(*(to)->from));
6883if((to)->from == NULL) goto fail;
6884if(copy_KerberosTime((from)->from, (to)->from)) goto fail;
6885}else
6886(to)->from = NULL;
6887if((from)->till) {
6888(to)->till = malloc(sizeof(*(to)->till));
6889if((to)->till == NULL) goto fail;
6890if(copy_KerberosTime((from)->till, (to)->till)) goto fail;
6891}else
6892(to)->till = NULL;
6893if((from)->rtime) {
6894(to)->rtime = malloc(sizeof(*(to)->rtime));
6895if((to)->rtime == NULL) goto fail;
6896if(copy_KerberosTime((from)->rtime, (to)->rtime)) goto fail;
6897}else
6898(to)->rtime = NULL;
6899if(copy_krb5int32(&(from)->nonce, &(to)->nonce)) goto fail;
6900if(((&(to)->etype)->val = malloc((&(from)->etype)->len * sizeof(*(&(to)->etype)->val))) == NULL && (&(from)->etype)->len != 0)
6901goto fail;
6902for((&(to)->etype)->len = 0; (&(to)->etype)->len < (&(from)->etype)->len; (&(to)->etype)->len++){
6903if(copy_ENCTYPE(&(&(from)->etype)->val[(&(to)->etype)->len], &(&(to)->etype)->val[(&(to)->etype)->len])) goto fail;
6904}
6905if((from)->addresses) {
6906(to)->addresses = malloc(sizeof(*(to)->addresses));
6907if((to)->addresses == NULL) goto fail;
6908if(copy_HostAddresses((from)->addresses, (to)->addresses)) goto fail;
6909}else
6910(to)->addresses = NULL;
6911if((from)->enc_authorization_data) {
6912(to)->enc_authorization_data = malloc(sizeof(*(to)->enc_authorization_data));
6913if((to)->enc_authorization_data == NULL) goto fail;
6914if(copy_EncryptedData((from)->enc_authorization_data, (to)->enc_authorization_data)) goto fail;
6915}else
6916(to)->enc_authorization_data = NULL;
6917if((from)->additional_tickets) {
6918(to)->additional_tickets = malloc(sizeof(*(to)->additional_tickets));
6919if((to)->additional_tickets == NULL) goto fail;
6920if((((to)->additional_tickets)->val = malloc(((from)->additional_tickets)->len * sizeof(*((to)->additional_tickets)->val))) == NULL && ((from)->additional_tickets)->len != 0)
6921goto fail;
6922for(((to)->additional_tickets)->len = 0; ((to)->additional_tickets)->len < ((from)->additional_tickets)->len; ((to)->additional_tickets)->len++){
6923if(copy_Ticket(&((from)->additional_tickets)->val[((to)->additional_tickets)->len], &((to)->additional_tickets)->val[((to)->additional_tickets)->len])) goto fail;
6924}
6925}else
6926(to)->additional_tickets = NULL;
6927return 0;
6928fail:
6929free_KDC_REQ_BODY(to);
6930return ENOMEM;
6931}
6932
6933int ASN1CALL
6934encode_KDC_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDC_REQ *data, size_t *size)
6935{
6936size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
6937size_t l HEIMDAL_UNUSED_ATTRIBUTE;
6938int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
6939
6940/* req-body */
6941{
6942size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6943ret = 0;
6944e = encode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
6945if (e) return e;
6946p -= l; len -= l; ret += l;
6947
6948e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
6949if (e) return e;
6950p -= l; len -= l; ret += l;
6951
6952ret += Top_tag_oldret;
6953}
6954/* padata */
6955if((data)->padata) {
6956size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6957ret = 0;
6958e = encode_METHOD_DATA(p, len, (data)->padata, &l);
6959if (e) return e;
6960p -= l; len -= l; ret += l;
6961
6962e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
6963if (e) return e;
6964p -= l; len -= l; ret += l;
6965
6966ret += Top_tag_oldret;
6967}
6968/* msg-type */
6969{
6970size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6971ret = 0;
6972e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
6973if (e) return e;
6974p -= l; len -= l; ret += l;
6975
6976e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
6977if (e) return e;
6978p -= l; len -= l; ret += l;
6979
6980ret += Top_tag_oldret;
6981}
6982/* pvno */
6983{
6984size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
6985ret = 0;
6986e = encode_krb5int32(p, len, &(data)->pvno, &l);
6987if (e) return e;
6988p -= l; len -= l; ret += l;
6989
6990e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
6991if (e) return e;
6992p -= l; len -= l; ret += l;
6993
6994ret += Top_tag_oldret;
6995}
6996e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
6997if (e) return e;
6998p -= l; len -= l; ret += l;
6999
7000*size = ret;
7001return 0;
7002}
7003
7004int ASN1CALL
7005decode_KDC_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDC_REQ *data, size_t *size)
7006{
7007size_t ret = 0;
7008size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7009int e HEIMDAL_UNUSED_ATTRIBUTE;
7010
7011memset(data, 0, sizeof(*data));
7012{
7013size_t Top_datalen, Top_oldlen;
7014Der_type Top_type;
7015e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7016if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7017if(e) goto fail;
7018p += l; len -= l; ret += l;
7019Top_oldlen = len;
7020if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7021len = Top_datalen;
7022{
7023size_t pvno_datalen, pvno_oldlen;
7024Der_type pvno_type;
7025e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 1, &pvno_datalen, &l);
7026if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
7027if(e) goto fail;
7028p += l; len -= l; ret += l;
7029pvno_oldlen = len;
7030if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7031len = pvno_datalen;
7032e = decode_krb5int32(p, len, &(data)->pvno, &l);
7033if(e) goto fail;
7034p += l; len -= l; ret += l;
7035len = pvno_oldlen - pvno_datalen;
7036}
7037{
7038size_t msg_type_datalen, msg_type_oldlen;
7039Der_type msg_type_type;
7040e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 2, &msg_type_datalen, &l);
7041if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
7042if(e) goto fail;
7043p += l; len -= l; ret += l;
7044msg_type_oldlen = len;
7045if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7046len = msg_type_datalen;
7047e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
7048if(e) goto fail;
7049p += l; len -= l; ret += l;
7050len = msg_type_oldlen - msg_type_datalen;
7051}
7052{
7053size_t padata_datalen, padata_oldlen;
7054Der_type padata_type;
7055e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 3, &padata_datalen, &l);
7056if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
7057if(e) {
7058(data)->padata = NULL;
7059} else {
7060(data)->padata = calloc(1, sizeof(*(data)->padata));
7061if ((data)->padata == NULL) { e = ENOMEM; goto fail; }
7062p += l; len -= l; ret += l;
7063padata_oldlen = len;
7064if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7065len = padata_datalen;
7066e = decode_METHOD_DATA(p, len, (data)->padata, &l);
7067if(e) goto fail;
7068p += l; len -= l; ret += l;
7069len = padata_oldlen - padata_datalen;
7070}
7071}
7072{
7073size_t req_body_datalen, req_body_oldlen;
7074Der_type req_body_type;
7075e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &req_body_type, 4, &req_body_datalen, &l);
7076if (e == 0 && req_body_type != CONS) { e = ASN1_BAD_ID; }
7077if(e) goto fail;
7078p += l; len -= l; ret += l;
7079req_body_oldlen = len;
7080if (req_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7081len = req_body_datalen;
7082e = decode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
7083if(e) goto fail;
7084p += l; len -= l; ret += l;
7085len = req_body_oldlen - req_body_datalen;
7086}
7087len = Top_oldlen - Top_datalen;
7088}
7089if(size) *size = ret;
7090return 0;
7091fail:
7092free_KDC_REQ(data);
7093return e;
7094}
7095
7096void ASN1CALL
7097free_KDC_REQ(KDC_REQ *data)
7098{
7099free_krb5int32(&(data)->pvno);
7100free_MESSAGE_TYPE(&(data)->msg_type);
7101if((data)->padata) {
7102free_METHOD_DATA((data)->padata);
7103free((data)->padata);
7104(data)->padata = NULL;
7105}
7106free_KDC_REQ_BODY(&(data)->req_body);
7107}
7108
7109size_t ASN1CALL
7110length_KDC_REQ(const KDC_REQ *data)
7111{
7112size_t ret = 0;
7113{
7114size_t Top_tag_oldret = ret;
7115ret = 0;
7116ret += length_krb5int32(&(data)->pvno);
7117ret += 1 + der_length_len (ret);
7118ret += Top_tag_oldret;
7119}
7120{
7121size_t Top_tag_oldret = ret;
7122ret = 0;
7123ret += length_MESSAGE_TYPE(&(data)->msg_type);
7124ret += 1 + der_length_len (ret);
7125ret += Top_tag_oldret;
7126}
7127if((data)->padata){
7128size_t Top_tag_oldret = ret;
7129ret = 0;
7130ret += length_METHOD_DATA((data)->padata);
7131ret += 1 + der_length_len (ret);
7132ret += Top_tag_oldret;
7133}
7134{
7135size_t Top_tag_oldret = ret;
7136ret = 0;
7137ret += length_KDC_REQ_BODY(&(data)->req_body);
7138ret += 1 + der_length_len (ret);
7139ret += Top_tag_oldret;
7140}
7141ret += 1 + der_length_len (ret);
7142return ret;
7143}
7144
7145int ASN1CALL
7146copy_KDC_REQ(const KDC_REQ *from, KDC_REQ *to)
7147{
7148memset(to, 0, sizeof(*to));
7149if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
7150if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
7151if((from)->padata) {
7152(to)->padata = malloc(sizeof(*(to)->padata));
7153if((to)->padata == NULL) goto fail;
7154if(copy_METHOD_DATA((from)->padata, (to)->padata)) goto fail;
7155}else
7156(to)->padata = NULL;
7157if(copy_KDC_REQ_BODY(&(from)->req_body, &(to)->req_body)) goto fail;
7158return 0;
7159fail:
7160free_KDC_REQ(to);
7161return ENOMEM;
7162}
7163
7164int ASN1CALL
7165encode_AS_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AS_REQ *data, size_t *size)
7166{
7167size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7168size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7169int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7170
7171e = encode_KDC_REQ(p, len, data, &l);
7172if (e) return e;
7173p -= l; len -= l; ret += l;
7174
7175e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 10, &l);
7176if (e) return e;
7177p -= l; len -= l; ret += l;
7178
7179*size = ret;
7180return 0;
7181}
7182
7183int ASN1CALL
7184decode_AS_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AS_REQ *data, size_t *size)
7185{
7186size_t ret = 0;
7187size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7188int e HEIMDAL_UNUSED_ATTRIBUTE;
7189
7190memset(data, 0, sizeof(*data));
7191{
7192size_t Top_datalen, Top_oldlen;
7193Der_type Top_type;
7194e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 10, &Top_datalen, &l);
7195if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7196if(e) goto fail;
7197p += l; len -= l; ret += l;
7198Top_oldlen = len;
7199if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7200len = Top_datalen;
7201e = decode_KDC_REQ(p, len, data, &l);
7202if(e) goto fail;
7203p += l; len -= l; ret += l;
7204len = Top_oldlen - Top_datalen;
7205}
7206if(size) *size = ret;
7207return 0;
7208fail:
7209free_AS_REQ(data);
7210return e;
7211}
7212
7213void ASN1CALL
7214free_AS_REQ(AS_REQ *data)
7215{
7216free_KDC_REQ(data);
7217}
7218
7219size_t ASN1CALL
7220length_AS_REQ(const AS_REQ *data)
7221{
7222size_t ret = 0;
7223ret += length_KDC_REQ(data);
7224ret += 1 + der_length_len (ret);
7225return ret;
7226}
7227
7228int ASN1CALL
7229copy_AS_REQ(const AS_REQ *from, AS_REQ *to)
7230{
7231memset(to, 0, sizeof(*to));
7232if(copy_KDC_REQ(from, to)) goto fail;
7233return 0;
7234fail:
7235free_AS_REQ(to);
7236return ENOMEM;
7237}
7238
7239int ASN1CALL
7240encode_TGS_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TGS_REQ *data, size_t *size)
7241{
7242size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7243size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7244int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7245
7246e = encode_KDC_REQ(p, len, data, &l);
7247if (e) return e;
7248p -= l; len -= l; ret += l;
7249
7250e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 12, &l);
7251if (e) return e;
7252p -= l; len -= l; ret += l;
7253
7254*size = ret;
7255return 0;
7256}
7257
7258int ASN1CALL
7259decode_TGS_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TGS_REQ *data, size_t *size)
7260{
7261size_t ret = 0;
7262size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7263int e HEIMDAL_UNUSED_ATTRIBUTE;
7264
7265memset(data, 0, sizeof(*data));
7266{
7267size_t Top_datalen, Top_oldlen;
7268Der_type Top_type;
7269e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 12, &Top_datalen, &l);
7270if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7271if(e) goto fail;
7272p += l; len -= l; ret += l;
7273Top_oldlen = len;
7274if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7275len = Top_datalen;
7276e = decode_KDC_REQ(p, len, data, &l);
7277if(e) goto fail;
7278p += l; len -= l; ret += l;
7279len = Top_oldlen - Top_datalen;
7280}
7281if(size) *size = ret;
7282return 0;
7283fail:
7284free_TGS_REQ(data);
7285return e;
7286}
7287
7288void ASN1CALL
7289free_TGS_REQ(TGS_REQ *data)
7290{
7291free_KDC_REQ(data);
7292}
7293
7294size_t ASN1CALL
7295length_TGS_REQ(const TGS_REQ *data)
7296{
7297size_t ret = 0;
7298ret += length_KDC_REQ(data);
7299ret += 1 + der_length_len (ret);
7300return ret;
7301}
7302
7303int ASN1CALL
7304copy_TGS_REQ(const TGS_REQ *from, TGS_REQ *to)
7305{
7306memset(to, 0, sizeof(*to));
7307if(copy_KDC_REQ(from, to)) goto fail;
7308return 0;
7309fail:
7310free_TGS_REQ(to);
7311return ENOMEM;
7312}
7313
7314int ASN1CALL
7315encode_PA_ENC_TS_ENC(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_ENC_TS_ENC *data, size_t *size)
7316{
7317size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7318size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7319int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7320
7321/* pausec */
7322if((data)->pausec) {
7323size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7324ret = 0;
7325e = encode_krb5int32(p, len, (data)->pausec, &l);
7326if (e) return e;
7327p -= l; len -= l; ret += l;
7328
7329e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
7330if (e) return e;
7331p -= l; len -= l; ret += l;
7332
7333ret += Top_tag_oldret;
7334}
7335/* patimestamp */
7336{
7337size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7338ret = 0;
7339e = encode_KerberosTime(p, len, &(data)->patimestamp, &l);
7340if (e) return e;
7341p -= l; len -= l; ret += l;
7342
7343e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
7344if (e) return e;
7345p -= l; len -= l; ret += l;
7346
7347ret += Top_tag_oldret;
7348}
7349e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7350if (e) return e;
7351p -= l; len -= l; ret += l;
7352
7353*size = ret;
7354return 0;
7355}
7356
7357int ASN1CALL
7358decode_PA_ENC_TS_ENC(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_ENC_TS_ENC *data, size_t *size)
7359{
7360size_t ret = 0;
7361size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7362int e HEIMDAL_UNUSED_ATTRIBUTE;
7363
7364memset(data, 0, sizeof(*data));
7365{
7366size_t Top_datalen, Top_oldlen;
7367Der_type Top_type;
7368e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7369if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7370if(e) goto fail;
7371p += l; len -= l; ret += l;
7372Top_oldlen = len;
7373if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7374len = Top_datalen;
7375{
7376size_t patimestamp_datalen, patimestamp_oldlen;
7377Der_type patimestamp_type;
7378e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &patimestamp_type, 0, &patimestamp_datalen, &l);
7379if (e == 0 && patimestamp_type != CONS) { e = ASN1_BAD_ID; }
7380if(e) goto fail;
7381p += l; len -= l; ret += l;
7382patimestamp_oldlen = len;
7383if (patimestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7384len = patimestamp_datalen;
7385e = decode_KerberosTime(p, len, &(data)->patimestamp, &l);
7386if(e) goto fail;
7387p += l; len -= l; ret += l;
7388len = patimestamp_oldlen - patimestamp_datalen;
7389}
7390{
7391size_t pausec_datalen, pausec_oldlen;
7392Der_type pausec_type;
7393e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pausec_type, 1, &pausec_datalen, &l);
7394if (e == 0 && pausec_type != CONS) { e = ASN1_BAD_ID; }
7395if(e) {
7396(data)->pausec = NULL;
7397} else {
7398(data)->pausec = calloc(1, sizeof(*(data)->pausec));
7399if ((data)->pausec == NULL) { e = ENOMEM; goto fail; }
7400p += l; len -= l; ret += l;
7401pausec_oldlen = len;
7402if (pausec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7403len = pausec_datalen;
7404e = decode_krb5int32(p, len, (data)->pausec, &l);
7405if(e) goto fail;
7406p += l; len -= l; ret += l;
7407len = pausec_oldlen - pausec_datalen;
7408}
7409}
7410len = Top_oldlen - Top_datalen;
7411}
7412if(size) *size = ret;
7413return 0;
7414fail:
7415free_PA_ENC_TS_ENC(data);
7416return e;
7417}
7418
7419void ASN1CALL
7420free_PA_ENC_TS_ENC(PA_ENC_TS_ENC *data)
7421{
7422free_KerberosTime(&(data)->patimestamp);
7423if((data)->pausec) {
7424free_krb5int32((data)->pausec);
7425free((data)->pausec);
7426(data)->pausec = NULL;
7427}
7428}
7429
7430size_t ASN1CALL
7431length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *data)
7432{
7433size_t ret = 0;
7434{
7435size_t Top_tag_oldret = ret;
7436ret = 0;
7437ret += length_KerberosTime(&(data)->patimestamp);
7438ret += 1 + der_length_len (ret);
7439ret += Top_tag_oldret;
7440}
7441if((data)->pausec){
7442size_t Top_tag_oldret = ret;
7443ret = 0;
7444ret += length_krb5int32((data)->pausec);
7445ret += 1 + der_length_len (ret);
7446ret += Top_tag_oldret;
7447}
7448ret += 1 + der_length_len (ret);
7449return ret;
7450}
7451
7452int ASN1CALL
7453copy_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *from, PA_ENC_TS_ENC *to)
7454{
7455memset(to, 0, sizeof(*to));
7456if(copy_KerberosTime(&(from)->patimestamp, &(to)->patimestamp)) goto fail;
7457if((from)->pausec) {
7458(to)->pausec = malloc(sizeof(*(to)->pausec));
7459if((to)->pausec == NULL) goto fail;
7460if(copy_krb5int32((from)->pausec, (to)->pausec)) goto fail;
7461}else
7462(to)->pausec = NULL;
7463return 0;
7464fail:
7465free_PA_ENC_TS_ENC(to);
7466return ENOMEM;
7467}
7468
7469int ASN1CALL
7470encode_PA_PAC_REQUEST(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_PAC_REQUEST *data, size_t *size)
7471{
7472size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7473size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7474int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7475
7476/* include-pac */
7477{
7478size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7479ret = 0;
7480e = der_put_boolean(p, len, &(data)->include_pac, &l);
7481if (e) return e;
7482p -= l; len -= l; ret += l;
7483
7484e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
7485if (e) return e;
7486p -= l; len -= l; ret += l;
7487
7488e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
7489if (e) return e;
7490p -= l; len -= l; ret += l;
7491
7492ret += Top_tag_oldret;
7493}
7494e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7495if (e) return e;
7496p -= l; len -= l; ret += l;
7497
7498*size = ret;
7499return 0;
7500}
7501
7502int ASN1CALL
7503decode_PA_PAC_REQUEST(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_PAC_REQUEST *data, size_t *size)
7504{
7505size_t ret = 0;
7506size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7507int e HEIMDAL_UNUSED_ATTRIBUTE;
7508
7509memset(data, 0, sizeof(*data));
7510{
7511size_t Top_datalen, Top_oldlen;
7512Der_type Top_type;
7513e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7514if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7515if(e) goto fail;
7516p += l; len -= l; ret += l;
7517Top_oldlen = len;
7518if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7519len = Top_datalen;
7520{
7521size_t include_pac_datalen, include_pac_oldlen;
7522Der_type include_pac_type;
7523e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &include_pac_type, 0, &include_pac_datalen, &l);
7524if (e == 0 && include_pac_type != CONS) { e = ASN1_BAD_ID; }
7525if(e) goto fail;
7526p += l; len -= l; ret += l;
7527include_pac_oldlen = len;
7528if (include_pac_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7529len = include_pac_datalen;
7530{
7531size_t include_pac_Tag_datalen, include_pac_Tag_oldlen;
7532Der_type include_pac_Tag_type;
7533e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &include_pac_Tag_type, UT_Boolean, &include_pac_Tag_datalen, &l);
7534if (e == 0 && include_pac_Tag_type != PRIM) { e = ASN1_BAD_ID; }
7535if(e) goto fail;
7536p += l; len -= l; ret += l;
7537include_pac_Tag_oldlen = len;
7538if (include_pac_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7539len = include_pac_Tag_datalen;
7540e = der_get_boolean(p, len, &(data)->include_pac, &l);
7541if(e) goto fail;
7542p += l; len -= l; ret += l;
7543len = include_pac_Tag_oldlen - include_pac_Tag_datalen;
7544}
7545len = include_pac_oldlen - include_pac_datalen;
7546}
7547len = Top_oldlen - Top_datalen;
7548}
7549if(size) *size = ret;
7550return 0;
7551fail:
7552free_PA_PAC_REQUEST(data);
7553return e;
7554}
7555
7556void ASN1CALL
7557free_PA_PAC_REQUEST(PA_PAC_REQUEST *data)
7558{
7559}
7560
7561size_t ASN1CALL
7562length_PA_PAC_REQUEST(const PA_PAC_REQUEST *data)
7563{
7564size_t ret = 0;
7565{
7566size_t Top_tag_oldret = ret;
7567ret = 0;
7568ret += 1;
7569ret += 1 + der_length_len (ret);
7570ret += 1 + der_length_len (ret);
7571ret += Top_tag_oldret;
7572}
7573ret += 1 + der_length_len (ret);
7574return ret;
7575}
7576
7577int ASN1CALL
7578copy_PA_PAC_REQUEST(const PA_PAC_REQUEST *from, PA_PAC_REQUEST *to)
7579{
7580memset(to, 0, sizeof(*to));
7581*(&(to)->include_pac) = *(&(from)->include_pac);
7582return 0;
7583}
7584
7585int ASN1CALL
7586encode_PROV_SRV_LOCATION(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PROV_SRV_LOCATION *data, size_t *size)
7587{
7588size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7589size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7590int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7591
7592e = der_put_general_string(p, len, data, &l);
7593if (e) return e;
7594p -= l; len -= l; ret += l;
7595
7596e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
7597if (e) return e;
7598p -= l; len -= l; ret += l;
7599
7600*size = ret;
7601return 0;
7602}
7603
7604int ASN1CALL
7605decode_PROV_SRV_LOCATION(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PROV_SRV_LOCATION *data, size_t *size)
7606{
7607size_t ret = 0;
7608size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7609int e HEIMDAL_UNUSED_ATTRIBUTE;
7610
7611memset(data, 0, sizeof(*data));
7612{
7613size_t Top_datalen, Top_oldlen;
7614Der_type Top_type;
7615e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_GeneralString, &Top_datalen, &l);
7616if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
7617if(e) goto fail;
7618p += l; len -= l; ret += l;
7619Top_oldlen = len;
7620if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7621len = Top_datalen;
7622e = der_get_general_string(p, len, data, &l);
7623if(e) goto fail;
7624p += l; len -= l; ret += l;
7625len = Top_oldlen - Top_datalen;
7626}
7627if(size) *size = ret;
7628return 0;
7629fail:
7630free_PROV_SRV_LOCATION(data);
7631return e;
7632}
7633
7634void ASN1CALL
7635free_PROV_SRV_LOCATION(PROV_SRV_LOCATION *data)
7636{
7637der_free_general_string(data);
7638}
7639
7640size_t ASN1CALL
7641length_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *data)
7642{
7643size_t ret = 0;
7644ret += der_length_general_string(data);
7645ret += 1 + der_length_len (ret);
7646return ret;
7647}
7648
7649int ASN1CALL
7650copy_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *from, PROV_SRV_LOCATION *to)
7651{
7652memset(to, 0, sizeof(*to));
7653if(der_copy_general_string(from, to)) goto fail;
7654return 0;
7655fail:
7656free_PROV_SRV_LOCATION(to);
7657return ENOMEM;
7658}
7659
7660int ASN1CALL
7661encode_KDC_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDC_REP *data, size_t *size)
7662{
7663size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
7664size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7665int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
7666
7667/* enc-part */
7668{
7669size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7670ret = 0;
7671e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
7672if (e) return e;
7673p -= l; len -= l; ret += l;
7674
7675e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
7676if (e) return e;
7677p -= l; len -= l; ret += l;
7678
7679ret += Top_tag_oldret;
7680}
7681/* ticket */
7682{
7683size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7684ret = 0;
7685e = encode_Ticket(p, len, &(data)->ticket, &l);
7686if (e) return e;
7687p -= l; len -= l; ret += l;
7688
7689e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
7690if (e) return e;
7691p -= l; len -= l; ret += l;
7692
7693ret += Top_tag_oldret;
7694}
7695/* cname */
7696{
7697size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7698ret = 0;
7699e = encode_PrincipalName(p, len, &(data)->cname, &l);
7700if (e) return e;
7701p -= l; len -= l; ret += l;
7702
7703e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
7704if (e) return e;
7705p -= l; len -= l; ret += l;
7706
7707ret += Top_tag_oldret;
7708}
7709/* crealm */
7710{
7711size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7712ret = 0;
7713e = encode_Realm(p, len, &(data)->crealm, &l);
7714if (e) return e;
7715p -= l; len -= l; ret += l;
7716
7717e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
7718if (e) return e;
7719p -= l; len -= l; ret += l;
7720
7721ret += Top_tag_oldret;
7722}
7723/* padata */
7724if((data)->padata) {
7725size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7726ret = 0;
7727e = encode_METHOD_DATA(p, len, (data)->padata, &l);
7728if (e) return e;
7729p -= l; len -= l; ret += l;
7730
7731e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
7732if (e) return e;
7733p -= l; len -= l; ret += l;
7734
7735ret += Top_tag_oldret;
7736}
7737/* msg-type */
7738{
7739size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7740ret = 0;
7741e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
7742if (e) return e;
7743p -= l; len -= l; ret += l;
7744
7745e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
7746if (e) return e;
7747p -= l; len -= l; ret += l;
7748
7749ret += Top_tag_oldret;
7750}
7751/* pvno */
7752{
7753size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
7754ret = 0;
7755e = encode_krb5int32(p, len, &(data)->pvno, &l);
7756if (e) return e;
7757p -= l; len -= l; ret += l;
7758
7759e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
7760if (e) return e;
7761p -= l; len -= l; ret += l;
7762
7763ret += Top_tag_oldret;
7764}
7765e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
7766if (e) return e;
7767p -= l; len -= l; ret += l;
7768
7769*size = ret;
7770return 0;
7771}
7772
7773int ASN1CALL
7774decode_KDC_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDC_REP *data, size_t *size)
7775{
7776size_t ret = 0;
7777size_t l HEIMDAL_UNUSED_ATTRIBUTE;
7778int e HEIMDAL_UNUSED_ATTRIBUTE;
7779
7780memset(data, 0, sizeof(*data));
7781{
7782size_t Top_datalen, Top_oldlen;
7783Der_type Top_type;
7784e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
7785if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
7786if(e) goto fail;
7787p += l; len -= l; ret += l;
7788Top_oldlen = len;
7789if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7790len = Top_datalen;
7791{
7792size_t pvno_datalen, pvno_oldlen;
7793Der_type pvno_type;
7794e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
7795if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
7796if(e) goto fail;
7797p += l; len -= l; ret += l;
7798pvno_oldlen = len;
7799if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7800len = pvno_datalen;
7801e = decode_krb5int32(p, len, &(data)->pvno, &l);
7802if(e) goto fail;
7803p += l; len -= l; ret += l;
7804len = pvno_oldlen - pvno_datalen;
7805}
7806{
7807size_t msg_type_datalen, msg_type_oldlen;
7808Der_type msg_type_type;
7809e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
7810if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
7811if(e) goto fail;
7812p += l; len -= l; ret += l;
7813msg_type_oldlen = len;
7814if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7815len = msg_type_datalen;
7816e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
7817if(e) goto fail;
7818p += l; len -= l; ret += l;
7819len = msg_type_oldlen - msg_type_datalen;
7820}
7821{
7822size_t padata_datalen, padata_oldlen;
7823Der_type padata_type;
7824e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 2, &padata_datalen, &l);
7825if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
7826if(e) {
7827(data)->padata = NULL;
7828} else {
7829(data)->padata = calloc(1, sizeof(*(data)->padata));
7830if ((data)->padata == NULL) { e = ENOMEM; goto fail; }
7831p += l; len -= l; ret += l;
7832padata_oldlen = len;
7833if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7834len = padata_datalen;
7835e = decode_METHOD_DATA(p, len, (data)->padata, &l);
7836if(e) goto fail;
7837p += l; len -= l; ret += l;
7838len = padata_oldlen - padata_datalen;
7839}
7840}
7841{
7842size_t crealm_datalen, crealm_oldlen;
7843Der_type crealm_type;
7844e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 3, &crealm_datalen, &l);
7845if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
7846if(e) goto fail;
7847p += l; len -= l; ret += l;
7848crealm_oldlen = len;
7849if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7850len = crealm_datalen;
7851e = decode_Realm(p, len, &(data)->crealm, &l);
7852if(e) goto fail;
7853p += l; len -= l; ret += l;
7854len = crealm_oldlen - crealm_datalen;
7855}
7856{
7857size_t cname_datalen, cname_oldlen;
7858Der_type cname_type;
7859e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 4, &cname_datalen, &l);
7860if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
7861if(e) goto fail;
7862p += l; len -= l; ret += l;
7863cname_oldlen = len;
7864if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7865len = cname_datalen;
7866e = decode_PrincipalName(p, len, &(data)->cname, &l);
7867if(e) goto fail;
7868p += l; len -= l; ret += l;
7869len = cname_oldlen - cname_datalen;
7870}
7871{
7872size_t ticket_datalen, ticket_oldlen;
7873Der_type ticket_type;
7874e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_type, 5, &ticket_datalen, &l);
7875if (e == 0 && ticket_type != CONS) { e = ASN1_BAD_ID; }
7876if(e) goto fail;
7877p += l; len -= l; ret += l;
7878ticket_oldlen = len;
7879if (ticket_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7880len = ticket_datalen;
7881e = decode_Ticket(p, len, &(data)->ticket, &l);
7882if(e) goto fail;
7883p += l; len -= l; ret += l;
7884len = ticket_oldlen - ticket_datalen;
7885}
7886{
7887size_t enc_part_datalen, enc_part_oldlen;
7888Der_type enc_part_type;
7889e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 6, &enc_part_datalen, &l);
7890if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
7891if(e) goto fail;
7892p += l; len -= l; ret += l;
7893enc_part_oldlen = len;
7894if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
7895len = enc_part_datalen;
7896e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
7897if(e) goto fail;
7898p += l; len -= l; ret += l;
7899len = enc_part_oldlen - enc_part_datalen;
7900}
7901len = Top_oldlen - Top_datalen;
7902}
7903if(size) *size = ret;
7904return 0;
7905fail:
7906free_KDC_REP(data);
7907return e;
7908}
7909
7910void ASN1CALL
7911free_KDC_REP(KDC_REP *data)
7912{
7913free_krb5int32(&(data)->pvno);
7914free_MESSAGE_TYPE(&(data)->msg_type);
7915if((data)->padata) {
7916free_METHOD_DATA((data)->padata);
7917free((data)->padata);
7918(data)->padata = NULL;
7919}
7920free_Realm(&(data)->crealm);
7921free_PrincipalName(&(data)->cname);
7922free_Ticket(&(data)->ticket);
7923free_EncryptedData(&(data)->enc_part);
7924}
7925
7926size_t ASN1CALL
7927length_KDC_REP(const KDC_REP *data)
7928{
7929size_t ret = 0;
7930{
7931size_t Top_tag_oldret = ret;
7932ret = 0;
7933ret += length_krb5int32(&(data)->pvno);
7934ret += 1 + der_length_len (ret);
7935ret += Top_tag_oldret;
7936}
7937{
7938size_t Top_tag_oldret = ret;
7939ret = 0;
7940ret += length_MESSAGE_TYPE(&(data)->msg_type);
7941ret += 1 + der_length_len (ret);
7942ret += Top_tag_oldret;
7943}
7944if((data)->padata){
7945size_t Top_tag_oldret = ret;
7946ret = 0;
7947ret += length_METHOD_DATA((data)->padata);
7948ret += 1 + der_length_len (ret);
7949ret += Top_tag_oldret;
7950}
7951{
7952size_t Top_tag_oldret = ret;
7953ret = 0;
7954ret += length_Realm(&(data)->crealm);
7955ret += 1 + der_length_len (ret);
7956ret += Top_tag_oldret;
7957}
7958{
7959size_t Top_tag_oldret = ret;
7960ret = 0;
7961ret += length_PrincipalName(&(data)->cname);
7962ret += 1 + der_length_len (ret);
7963ret += Top_tag_oldret;
7964}
7965{
7966size_t Top_tag_oldret = ret;
7967ret = 0;
7968ret += length_Ticket(&(data)->ticket);
7969ret += 1 + der_length_len (ret);
7970ret += Top_tag_oldret;
7971}
7972{
7973size_t Top_tag_oldret = ret;
7974ret = 0;
7975ret += length_EncryptedData(&(data)->enc_part);
7976ret += 1 + der_length_len (ret);
7977ret += Top_tag_oldret;
7978}
7979ret += 1 + der_length_len (ret);
7980return ret;
7981}
7982
7983int ASN1CALL
7984copy_KDC_REP(const KDC_REP *from, KDC_REP *to)
7985{
7986memset(to, 0, sizeof(*to));
7987if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
7988if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
7989if((from)->padata) {
7990(to)->padata = malloc(sizeof(*(to)->padata));
7991if((to)->padata == NULL) goto fail;
7992if(copy_METHOD_DATA((from)->padata, (to)->padata)) goto fail;
7993}else
7994(to)->padata = NULL;
7995if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
7996if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
7997if(copy_Ticket(&(from)->ticket, &(to)->ticket)) goto fail;
7998if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
7999return 0;
8000fail:
8001free_KDC_REP(to);
8002return ENOMEM;
8003}
8004
8005int ASN1CALL
8006encode_AS_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AS_REP *data, size_t *size)
8007{
8008size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8009size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8010int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8011
8012e = encode_KDC_REP(p, len, data, &l);
8013if (e) return e;
8014p -= l; len -= l; ret += l;
8015
8016e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 11, &l);
8017if (e) return e;
8018p -= l; len -= l; ret += l;
8019
8020*size = ret;
8021return 0;
8022}
8023
8024int ASN1CALL
8025decode_AS_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AS_REP *data, size_t *size)
8026{
8027size_t ret = 0;
8028size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8029int e HEIMDAL_UNUSED_ATTRIBUTE;
8030
8031memset(data, 0, sizeof(*data));
8032{
8033size_t Top_datalen, Top_oldlen;
8034Der_type Top_type;
8035e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 11, &Top_datalen, &l);
8036if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8037if(e) goto fail;
8038p += l; len -= l; ret += l;
8039Top_oldlen = len;
8040if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8041len = Top_datalen;
8042e = decode_KDC_REP(p, len, data, &l);
8043if(e) goto fail;
8044p += l; len -= l; ret += l;
8045len = Top_oldlen - Top_datalen;
8046}
8047if(size) *size = ret;
8048return 0;
8049fail:
8050free_AS_REP(data);
8051return e;
8052}
8053
8054void ASN1CALL
8055free_AS_REP(AS_REP *data)
8056{
8057free_KDC_REP(data);
8058}
8059
8060size_t ASN1CALL
8061length_AS_REP(const AS_REP *data)
8062{
8063size_t ret = 0;
8064ret += length_KDC_REP(data);
8065ret += 1 + der_length_len (ret);
8066return ret;
8067}
8068
8069int ASN1CALL
8070copy_AS_REP(const AS_REP *from, AS_REP *to)
8071{
8072memset(to, 0, sizeof(*to));
8073if(copy_KDC_REP(from, to)) goto fail;
8074return 0;
8075fail:
8076free_AS_REP(to);
8077return ENOMEM;
8078}
8079
8080int ASN1CALL
8081encode_TGS_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TGS_REP *data, size_t *size)
8082{
8083size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8084size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8085int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8086
8087e = encode_KDC_REP(p, len, data, &l);
8088if (e) return e;
8089p -= l; len -= l; ret += l;
8090
8091e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 13, &l);
8092if (e) return e;
8093p -= l; len -= l; ret += l;
8094
8095*size = ret;
8096return 0;
8097}
8098
8099int ASN1CALL
8100decode_TGS_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TGS_REP *data, size_t *size)
8101{
8102size_t ret = 0;
8103size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8104int e HEIMDAL_UNUSED_ATTRIBUTE;
8105
8106memset(data, 0, sizeof(*data));
8107{
8108size_t Top_datalen, Top_oldlen;
8109Der_type Top_type;
8110e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 13, &Top_datalen, &l);
8111if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8112if(e) goto fail;
8113p += l; len -= l; ret += l;
8114Top_oldlen = len;
8115if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8116len = Top_datalen;
8117e = decode_KDC_REP(p, len, data, &l);
8118if(e) goto fail;
8119p += l; len -= l; ret += l;
8120len = Top_oldlen - Top_datalen;
8121}
8122if(size) *size = ret;
8123return 0;
8124fail:
8125free_TGS_REP(data);
8126return e;
8127}
8128
8129void ASN1CALL
8130free_TGS_REP(TGS_REP *data)
8131{
8132free_KDC_REP(data);
8133}
8134
8135size_t ASN1CALL
8136length_TGS_REP(const TGS_REP *data)
8137{
8138size_t ret = 0;
8139ret += length_KDC_REP(data);
8140ret += 1 + der_length_len (ret);
8141return ret;
8142}
8143
8144int ASN1CALL
8145copy_TGS_REP(const TGS_REP *from, TGS_REP *to)
8146{
8147memset(to, 0, sizeof(*to));
8148if(copy_KDC_REP(from, to)) goto fail;
8149return 0;
8150fail:
8151free_TGS_REP(to);
8152return ENOMEM;
8153}
8154
8155int ASN1CALL
8156encode_EncKDCRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncKDCRepPart *data, size_t *size)
8157{
8158size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8159size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8160int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8161
8162/* encrypted-pa-data */
8163if((data)->encrypted_pa_data) {
8164size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8165ret = 0;
8166e = encode_METHOD_DATA(p, len, (data)->encrypted_pa_data, &l);
8167if (e) return e;
8168p -= l; len -= l; ret += l;
8169
8170e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 12, &l);
8171if (e) return e;
8172p -= l; len -= l; ret += l;
8173
8174ret += Top_tag_oldret;
8175}
8176/* caddr */
8177if((data)->caddr) {
8178size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8179ret = 0;
8180e = encode_HostAddresses(p, len, (data)->caddr, &l);
8181if (e) return e;
8182p -= l; len -= l; ret += l;
8183
8184e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
8185if (e) return e;
8186p -= l; len -= l; ret += l;
8187
8188ret += Top_tag_oldret;
8189}
8190/* sname */
8191{
8192size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8193ret = 0;
8194e = encode_PrincipalName(p, len, &(data)->sname, &l);
8195if (e) return e;
8196p -= l; len -= l; ret += l;
8197
8198e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
8199if (e) return e;
8200p -= l; len -= l; ret += l;
8201
8202ret += Top_tag_oldret;
8203}
8204/* srealm */
8205{
8206size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8207ret = 0;
8208e = encode_Realm(p, len, &(data)->srealm, &l);
8209if (e) return e;
8210p -= l; len -= l; ret += l;
8211
8212e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
8213if (e) return e;
8214p -= l; len -= l; ret += l;
8215
8216ret += Top_tag_oldret;
8217}
8218/* renew-till */
8219if((data)->renew_till) {
8220size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8221ret = 0;
8222e = encode_KerberosTime(p, len, (data)->renew_till, &l);
8223if (e) return e;
8224p -= l; len -= l; ret += l;
8225
8226e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
8227if (e) return e;
8228p -= l; len -= l; ret += l;
8229
8230ret += Top_tag_oldret;
8231}
8232/* endtime */
8233{
8234size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8235ret = 0;
8236e = encode_KerberosTime(p, len, &(data)->endtime, &l);
8237if (e) return e;
8238p -= l; len -= l; ret += l;
8239
8240e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
8241if (e) return e;
8242p -= l; len -= l; ret += l;
8243
8244ret += Top_tag_oldret;
8245}
8246/* starttime */
8247if((data)->starttime) {
8248size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8249ret = 0;
8250e = encode_KerberosTime(p, len, (data)->starttime, &l);
8251if (e) return e;
8252p -= l; len -= l; ret += l;
8253
8254e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
8255if (e) return e;
8256p -= l; len -= l; ret += l;
8257
8258ret += Top_tag_oldret;
8259}
8260/* authtime */
8261{
8262size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8263ret = 0;
8264e = encode_KerberosTime(p, len, &(data)->authtime, &l);
8265if (e) return e;
8266p -= l; len -= l; ret += l;
8267
8268e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
8269if (e) return e;
8270p -= l; len -= l; ret += l;
8271
8272ret += Top_tag_oldret;
8273}
8274/* flags */
8275{
8276size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8277ret = 0;
8278e = encode_TicketFlags(p, len, &(data)->flags, &l);
8279if (e) return e;
8280p -= l; len -= l; ret += l;
8281
8282e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
8283if (e) return e;
8284p -= l; len -= l; ret += l;
8285
8286ret += Top_tag_oldret;
8287}
8288/* key-expiration */
8289if((data)->key_expiration) {
8290size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8291ret = 0;
8292e = encode_KerberosTime(p, len, (data)->key_expiration, &l);
8293if (e) return e;
8294p -= l; len -= l; ret += l;
8295
8296e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
8297if (e) return e;
8298p -= l; len -= l; ret += l;
8299
8300ret += Top_tag_oldret;
8301}
8302/* nonce */
8303{
8304size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8305ret = 0;
8306e = encode_krb5int32(p, len, &(data)->nonce, &l);
8307if (e) return e;
8308p -= l; len -= l; ret += l;
8309
8310e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
8311if (e) return e;
8312p -= l; len -= l; ret += l;
8313
8314ret += Top_tag_oldret;
8315}
8316/* last-req */
8317{
8318size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8319ret = 0;
8320e = encode_LastReq(p, len, &(data)->last_req, &l);
8321if (e) return e;
8322p -= l; len -= l; ret += l;
8323
8324e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
8325if (e) return e;
8326p -= l; len -= l; ret += l;
8327
8328ret += Top_tag_oldret;
8329}
8330/* key */
8331{
8332size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8333ret = 0;
8334e = encode_EncryptionKey(p, len, &(data)->key, &l);
8335if (e) return e;
8336p -= l; len -= l; ret += l;
8337
8338e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
8339if (e) return e;
8340p -= l; len -= l; ret += l;
8341
8342ret += Top_tag_oldret;
8343}
8344e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
8345if (e) return e;
8346p -= l; len -= l; ret += l;
8347
8348*size = ret;
8349return 0;
8350}
8351
8352int ASN1CALL
8353decode_EncKDCRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncKDCRepPart *data, size_t *size)
8354{
8355size_t ret = 0;
8356size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8357int e HEIMDAL_UNUSED_ATTRIBUTE;
8358
8359memset(data, 0, sizeof(*data));
8360{
8361size_t Top_datalen, Top_oldlen;
8362Der_type Top_type;
8363e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
8364if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8365if(e) goto fail;
8366p += l; len -= l; ret += l;
8367Top_oldlen = len;
8368if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8369len = Top_datalen;
8370{
8371size_t key_datalen, key_oldlen;
8372Der_type key_type;
8373e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 0, &key_datalen, &l);
8374if (e == 0 && key_type != CONS) { e = ASN1_BAD_ID; }
8375if(e) goto fail;
8376p += l; len -= l; ret += l;
8377key_oldlen = len;
8378if (key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8379len = key_datalen;
8380e = decode_EncryptionKey(p, len, &(data)->key, &l);
8381if(e) goto fail;
8382p += l; len -= l; ret += l;
8383len = key_oldlen - key_datalen;
8384}
8385{
8386size_t last_req_datalen, last_req_oldlen;
8387Der_type last_req_type;
8388e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &last_req_type, 1, &last_req_datalen, &l);
8389if (e == 0 && last_req_type != CONS) { e = ASN1_BAD_ID; }
8390if(e) goto fail;
8391p += l; len -= l; ret += l;
8392last_req_oldlen = len;
8393if (last_req_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8394len = last_req_datalen;
8395e = decode_LastReq(p, len, &(data)->last_req, &l);
8396if(e) goto fail;
8397p += l; len -= l; ret += l;
8398len = last_req_oldlen - last_req_datalen;
8399}
8400{
8401size_t nonce_datalen, nonce_oldlen;
8402Der_type nonce_type;
8403e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonce_type, 2, &nonce_datalen, &l);
8404if (e == 0 && nonce_type != CONS) { e = ASN1_BAD_ID; }
8405if(e) goto fail;
8406p += l; len -= l; ret += l;
8407nonce_oldlen = len;
8408if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8409len = nonce_datalen;
8410e = decode_krb5int32(p, len, &(data)->nonce, &l);
8411if(e) goto fail;
8412p += l; len -= l; ret += l;
8413len = nonce_oldlen - nonce_datalen;
8414}
8415{
8416size_t key_expiration_datalen, key_expiration_oldlen;
8417Der_type key_expiration_type;
8418e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_expiration_type, 3, &key_expiration_datalen, &l);
8419if (e == 0 && key_expiration_type != CONS) { e = ASN1_BAD_ID; }
8420if(e) {
8421(data)->key_expiration = NULL;
8422} else {
8423(data)->key_expiration = calloc(1, sizeof(*(data)->key_expiration));
8424if ((data)->key_expiration == NULL) { e = ENOMEM; goto fail; }
8425p += l; len -= l; ret += l;
8426key_expiration_oldlen = len;
8427if (key_expiration_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8428len = key_expiration_datalen;
8429e = decode_KerberosTime(p, len, (data)->key_expiration, &l);
8430if(e) goto fail;
8431p += l; len -= l; ret += l;
8432len = key_expiration_oldlen - key_expiration_datalen;
8433}
8434}
8435{
8436size_t flags_datalen, flags_oldlen;
8437Der_type flags_type;
8438e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 4, &flags_datalen, &l);
8439if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
8440if(e) goto fail;
8441p += l; len -= l; ret += l;
8442flags_oldlen = len;
8443if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8444len = flags_datalen;
8445e = decode_TicketFlags(p, len, &(data)->flags, &l);
8446if(e) goto fail;
8447p += l; len -= l; ret += l;
8448len = flags_oldlen - flags_datalen;
8449}
8450{
8451size_t authtime_datalen, authtime_oldlen;
8452Der_type authtime_type;
8453e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 5, &authtime_datalen, &l);
8454if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
8455if(e) goto fail;
8456p += l; len -= l; ret += l;
8457authtime_oldlen = len;
8458if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8459len = authtime_datalen;
8460e = decode_KerberosTime(p, len, &(data)->authtime, &l);
8461if(e) goto fail;
8462p += l; len -= l; ret += l;
8463len = authtime_oldlen - authtime_datalen;
8464}
8465{
8466size_t starttime_datalen, starttime_oldlen;
8467Der_type starttime_type;
8468e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 6, &starttime_datalen, &l);
8469if (e == 0 && starttime_type != CONS) { e = ASN1_BAD_ID; }
8470if(e) {
8471(data)->starttime = NULL;
8472} else {
8473(data)->starttime = calloc(1, sizeof(*(data)->starttime));
8474if ((data)->starttime == NULL) { e = ENOMEM; goto fail; }
8475p += l; len -= l; ret += l;
8476starttime_oldlen = len;
8477if (starttime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8478len = starttime_datalen;
8479e = decode_KerberosTime(p, len, (data)->starttime, &l);
8480if(e) goto fail;
8481p += l; len -= l; ret += l;
8482len = starttime_oldlen - starttime_datalen;
8483}
8484}
8485{
8486size_t endtime_datalen, endtime_oldlen;
8487Der_type endtime_type;
8488e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 7, &endtime_datalen, &l);
8489if (e == 0 && endtime_type != CONS) { e = ASN1_BAD_ID; }
8490if(e) goto fail;
8491p += l; len -= l; ret += l;
8492endtime_oldlen = len;
8493if (endtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8494len = endtime_datalen;
8495e = decode_KerberosTime(p, len, &(data)->endtime, &l);
8496if(e) goto fail;
8497p += l; len -= l; ret += l;
8498len = endtime_oldlen - endtime_datalen;
8499}
8500{
8501size_t renew_till_datalen, renew_till_oldlen;
8502Der_type renew_till_type;
8503e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 8, &renew_till_datalen, &l);
8504if (e == 0 && renew_till_type != CONS) { e = ASN1_BAD_ID; }
8505if(e) {
8506(data)->renew_till = NULL;
8507} else {
8508(data)->renew_till = calloc(1, sizeof(*(data)->renew_till));
8509if ((data)->renew_till == NULL) { e = ENOMEM; goto fail; }
8510p += l; len -= l; ret += l;
8511renew_till_oldlen = len;
8512if (renew_till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8513len = renew_till_datalen;
8514e = decode_KerberosTime(p, len, (data)->renew_till, &l);
8515if(e) goto fail;
8516p += l; len -= l; ret += l;
8517len = renew_till_oldlen - renew_till_datalen;
8518}
8519}
8520{
8521size_t srealm_datalen, srealm_oldlen;
8522Der_type srealm_type;
8523e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &srealm_type, 9, &srealm_datalen, &l);
8524if (e == 0 && srealm_type != CONS) { e = ASN1_BAD_ID; }
8525if(e) goto fail;
8526p += l; len -= l; ret += l;
8527srealm_oldlen = len;
8528if (srealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8529len = srealm_datalen;
8530e = decode_Realm(p, len, &(data)->srealm, &l);
8531if(e) goto fail;
8532p += l; len -= l; ret += l;
8533len = srealm_oldlen - srealm_datalen;
8534}
8535{
8536size_t sname_datalen, sname_oldlen;
8537Der_type sname_type;
8538e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 10, &sname_datalen, &l);
8539if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
8540if(e) goto fail;
8541p += l; len -= l; ret += l;
8542sname_oldlen = len;
8543if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8544len = sname_datalen;
8545e = decode_PrincipalName(p, len, &(data)->sname, &l);
8546if(e) goto fail;
8547p += l; len -= l; ret += l;
8548len = sname_oldlen - sname_datalen;
8549}
8550{
8551size_t caddr_datalen, caddr_oldlen;
8552Der_type caddr_type;
8553e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &caddr_type, 11, &caddr_datalen, &l);
8554if (e == 0 && caddr_type != CONS) { e = ASN1_BAD_ID; }
8555if(e) {
8556(data)->caddr = NULL;
8557} else {
8558(data)->caddr = calloc(1, sizeof(*(data)->caddr));
8559if ((data)->caddr == NULL) { e = ENOMEM; goto fail; }
8560p += l; len -= l; ret += l;
8561caddr_oldlen = len;
8562if (caddr_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8563len = caddr_datalen;
8564e = decode_HostAddresses(p, len, (data)->caddr, &l);
8565if(e) goto fail;
8566p += l; len -= l; ret += l;
8567len = caddr_oldlen - caddr_datalen;
8568}
8569}
8570{
8571size_t encrypted_pa_data_datalen, encrypted_pa_data_oldlen;
8572Der_type encrypted_pa_data_type;
8573e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &encrypted_pa_data_type, 12, &encrypted_pa_data_datalen, &l);
8574if (e == 0 && encrypted_pa_data_type != CONS) { e = ASN1_BAD_ID; }
8575if(e) {
8576(data)->encrypted_pa_data = NULL;
8577} else {
8578(data)->encrypted_pa_data = calloc(1, sizeof(*(data)->encrypted_pa_data));
8579if ((data)->encrypted_pa_data == NULL) { e = ENOMEM; goto fail; }
8580p += l; len -= l; ret += l;
8581encrypted_pa_data_oldlen = len;
8582if (encrypted_pa_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8583len = encrypted_pa_data_datalen;
8584e = decode_METHOD_DATA(p, len, (data)->encrypted_pa_data, &l);
8585if(e) goto fail;
8586p += l; len -= l; ret += l;
8587len = encrypted_pa_data_oldlen - encrypted_pa_data_datalen;
8588}
8589}
8590len = Top_oldlen - Top_datalen;
8591}
8592if(size) *size = ret;
8593return 0;
8594fail:
8595free_EncKDCRepPart(data);
8596return e;
8597}
8598
8599void ASN1CALL
8600free_EncKDCRepPart(EncKDCRepPart *data)
8601{
8602free_EncryptionKey(&(data)->key);
8603free_LastReq(&(data)->last_req);
8604free_krb5int32(&(data)->nonce);
8605if((data)->key_expiration) {
8606free_KerberosTime((data)->key_expiration);
8607free((data)->key_expiration);
8608(data)->key_expiration = NULL;
8609}
8610free_TicketFlags(&(data)->flags);
8611free_KerberosTime(&(data)->authtime);
8612if((data)->starttime) {
8613free_KerberosTime((data)->starttime);
8614free((data)->starttime);
8615(data)->starttime = NULL;
8616}
8617free_KerberosTime(&(data)->endtime);
8618if((data)->renew_till) {
8619free_KerberosTime((data)->renew_till);
8620free((data)->renew_till);
8621(data)->renew_till = NULL;
8622}
8623free_Realm(&(data)->srealm);
8624free_PrincipalName(&(data)->sname);
8625if((data)->caddr) {
8626free_HostAddresses((data)->caddr);
8627free((data)->caddr);
8628(data)->caddr = NULL;
8629}
8630if((data)->encrypted_pa_data) {
8631free_METHOD_DATA((data)->encrypted_pa_data);
8632free((data)->encrypted_pa_data);
8633(data)->encrypted_pa_data = NULL;
8634}
8635}
8636
8637size_t ASN1CALL
8638length_EncKDCRepPart(const EncKDCRepPart *data)
8639{
8640size_t ret = 0;
8641{
8642size_t Top_tag_oldret = ret;
8643ret = 0;
8644ret += length_EncryptionKey(&(data)->key);
8645ret += 1 + der_length_len (ret);
8646ret += Top_tag_oldret;
8647}
8648{
8649size_t Top_tag_oldret = ret;
8650ret = 0;
8651ret += length_LastReq(&(data)->last_req);
8652ret += 1 + der_length_len (ret);
8653ret += Top_tag_oldret;
8654}
8655{
8656size_t Top_tag_oldret = ret;
8657ret = 0;
8658ret += length_krb5int32(&(data)->nonce);
8659ret += 1 + der_length_len (ret);
8660ret += Top_tag_oldret;
8661}
8662if((data)->key_expiration){
8663size_t Top_tag_oldret = ret;
8664ret = 0;
8665ret += length_KerberosTime((data)->key_expiration);
8666ret += 1 + der_length_len (ret);
8667ret += Top_tag_oldret;
8668}
8669{
8670size_t Top_tag_oldret = ret;
8671ret = 0;
8672ret += length_TicketFlags(&(data)->flags);
8673ret += 1 + der_length_len (ret);
8674ret += Top_tag_oldret;
8675}
8676{
8677size_t Top_tag_oldret = ret;
8678ret = 0;
8679ret += length_KerberosTime(&(data)->authtime);
8680ret += 1 + der_length_len (ret);
8681ret += Top_tag_oldret;
8682}
8683if((data)->starttime){
8684size_t Top_tag_oldret = ret;
8685ret = 0;
8686ret += length_KerberosTime((data)->starttime);
8687ret += 1 + der_length_len (ret);
8688ret += Top_tag_oldret;
8689}
8690{
8691size_t Top_tag_oldret = ret;
8692ret = 0;
8693ret += length_KerberosTime(&(data)->endtime);
8694ret += 1 + der_length_len (ret);
8695ret += Top_tag_oldret;
8696}
8697if((data)->renew_till){
8698size_t Top_tag_oldret = ret;
8699ret = 0;
8700ret += length_KerberosTime((data)->renew_till);
8701ret += 1 + der_length_len (ret);
8702ret += Top_tag_oldret;
8703}
8704{
8705size_t Top_tag_oldret = ret;
8706ret = 0;
8707ret += length_Realm(&(data)->srealm);
8708ret += 1 + der_length_len (ret);
8709ret += Top_tag_oldret;
8710}
8711{
8712size_t Top_tag_oldret = ret;
8713ret = 0;
8714ret += length_PrincipalName(&(data)->sname);
8715ret += 1 + der_length_len (ret);
8716ret += Top_tag_oldret;
8717}
8718if((data)->caddr){
8719size_t Top_tag_oldret = ret;
8720ret = 0;
8721ret += length_HostAddresses((data)->caddr);
8722ret += 1 + der_length_len (ret);
8723ret += Top_tag_oldret;
8724}
8725if((data)->encrypted_pa_data){
8726size_t Top_tag_oldret = ret;
8727ret = 0;
8728ret += length_METHOD_DATA((data)->encrypted_pa_data);
8729ret += 1 + der_length_len (ret);
8730ret += Top_tag_oldret;
8731}
8732ret += 1 + der_length_len (ret);
8733return ret;
8734}
8735
8736int ASN1CALL
8737copy_EncKDCRepPart(const EncKDCRepPart *from, EncKDCRepPart *to)
8738{
8739memset(to, 0, sizeof(*to));
8740if(copy_EncryptionKey(&(from)->key, &(to)->key)) goto fail;
8741if(copy_LastReq(&(from)->last_req, &(to)->last_req)) goto fail;
8742if(copy_krb5int32(&(from)->nonce, &(to)->nonce)) goto fail;
8743if((from)->key_expiration) {
8744(to)->key_expiration = malloc(sizeof(*(to)->key_expiration));
8745if((to)->key_expiration == NULL) goto fail;
8746if(copy_KerberosTime((from)->key_expiration, (to)->key_expiration)) goto fail;
8747}else
8748(to)->key_expiration = NULL;
8749if(copy_TicketFlags(&(from)->flags, &(to)->flags)) goto fail;
8750if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) goto fail;
8751if((from)->starttime) {
8752(to)->starttime = malloc(sizeof(*(to)->starttime));
8753if((to)->starttime == NULL) goto fail;
8754if(copy_KerberosTime((from)->starttime, (to)->starttime)) goto fail;
8755}else
8756(to)->starttime = NULL;
8757if(copy_KerberosTime(&(from)->endtime, &(to)->endtime)) goto fail;
8758if((from)->renew_till) {
8759(to)->renew_till = malloc(sizeof(*(to)->renew_till));
8760if((to)->renew_till == NULL) goto fail;
8761if(copy_KerberosTime((from)->renew_till, (to)->renew_till)) goto fail;
8762}else
8763(to)->renew_till = NULL;
8764if(copy_Realm(&(from)->srealm, &(to)->srealm)) goto fail;
8765if(copy_PrincipalName(&(from)->sname, &(to)->sname)) goto fail;
8766if((from)->caddr) {
8767(to)->caddr = malloc(sizeof(*(to)->caddr));
8768if((to)->caddr == NULL) goto fail;
8769if(copy_HostAddresses((from)->caddr, (to)->caddr)) goto fail;
8770}else
8771(to)->caddr = NULL;
8772if((from)->encrypted_pa_data) {
8773(to)->encrypted_pa_data = malloc(sizeof(*(to)->encrypted_pa_data));
8774if((to)->encrypted_pa_data == NULL) goto fail;
8775if(copy_METHOD_DATA((from)->encrypted_pa_data, (to)->encrypted_pa_data)) goto fail;
8776}else
8777(to)->encrypted_pa_data = NULL;
8778return 0;
8779fail:
8780free_EncKDCRepPart(to);
8781return ENOMEM;
8782}
8783
8784int ASN1CALL
8785encode_EncASRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncASRepPart *data, size_t *size)
8786{
8787size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8788size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8789int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8790
8791e = encode_EncKDCRepPart(p, len, data, &l);
8792if (e) return e;
8793p -= l; len -= l; ret += l;
8794
8795e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 25, &l);
8796if (e) return e;
8797p -= l; len -= l; ret += l;
8798
8799*size = ret;
8800return 0;
8801}
8802
8803int ASN1CALL
8804decode_EncASRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncASRepPart *data, size_t *size)
8805{
8806size_t ret = 0;
8807size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8808int e HEIMDAL_UNUSED_ATTRIBUTE;
8809
8810memset(data, 0, sizeof(*data));
8811{
8812size_t Top_datalen, Top_oldlen;
8813Der_type Top_type;
8814e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 25, &Top_datalen, &l);
8815if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8816if(e) goto fail;
8817p += l; len -= l; ret += l;
8818Top_oldlen = len;
8819if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8820len = Top_datalen;
8821e = decode_EncKDCRepPart(p, len, data, &l);
8822if(e) goto fail;
8823p += l; len -= l; ret += l;
8824len = Top_oldlen - Top_datalen;
8825}
8826if(size) *size = ret;
8827return 0;
8828fail:
8829free_EncASRepPart(data);
8830return e;
8831}
8832
8833void ASN1CALL
8834free_EncASRepPart(EncASRepPart *data)
8835{
8836free_EncKDCRepPart(data);
8837}
8838
8839size_t ASN1CALL
8840length_EncASRepPart(const EncASRepPart *data)
8841{
8842size_t ret = 0;
8843ret += length_EncKDCRepPart(data);
8844ret += 1 + der_length_len (ret);
8845return ret;
8846}
8847
8848int ASN1CALL
8849copy_EncASRepPart(const EncASRepPart *from, EncASRepPart *to)
8850{
8851memset(to, 0, sizeof(*to));
8852if(copy_EncKDCRepPart(from, to)) goto fail;
8853return 0;
8854fail:
8855free_EncASRepPart(to);
8856return ENOMEM;
8857}
8858
8859int ASN1CALL
8860encode_EncTGSRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncTGSRepPart *data, size_t *size)
8861{
8862size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8863size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8864int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8865
8866e = encode_EncKDCRepPart(p, len, data, &l);
8867if (e) return e;
8868p -= l; len -= l; ret += l;
8869
8870e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 26, &l);
8871if (e) return e;
8872p -= l; len -= l; ret += l;
8873
8874*size = ret;
8875return 0;
8876}
8877
8878int ASN1CALL
8879decode_EncTGSRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncTGSRepPart *data, size_t *size)
8880{
8881size_t ret = 0;
8882size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8883int e HEIMDAL_UNUSED_ATTRIBUTE;
8884
8885memset(data, 0, sizeof(*data));
8886{
8887size_t Top_datalen, Top_oldlen;
8888Der_type Top_type;
8889e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 26, &Top_datalen, &l);
8890if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
8891if(e) goto fail;
8892p += l; len -= l; ret += l;
8893Top_oldlen = len;
8894if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
8895len = Top_datalen;
8896e = decode_EncKDCRepPart(p, len, data, &l);
8897if(e) goto fail;
8898p += l; len -= l; ret += l;
8899len = Top_oldlen - Top_datalen;
8900}
8901if(size) *size = ret;
8902return 0;
8903fail:
8904free_EncTGSRepPart(data);
8905return e;
8906}
8907
8908void ASN1CALL
8909free_EncTGSRepPart(EncTGSRepPart *data)
8910{
8911free_EncKDCRepPart(data);
8912}
8913
8914size_t ASN1CALL
8915length_EncTGSRepPart(const EncTGSRepPart *data)
8916{
8917size_t ret = 0;
8918ret += length_EncKDCRepPart(data);
8919ret += 1 + der_length_len (ret);
8920return ret;
8921}
8922
8923int ASN1CALL
8924copy_EncTGSRepPart(const EncTGSRepPart *from, EncTGSRepPart *to)
8925{
8926memset(to, 0, sizeof(*to));
8927if(copy_EncKDCRepPart(from, to)) goto fail;
8928return 0;
8929fail:
8930free_EncTGSRepPart(to);
8931return ENOMEM;
8932}
8933
8934int ASN1CALL
8935encode_AP_REQ(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AP_REQ *data, size_t *size)
8936{
8937size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
8938size_t l HEIMDAL_UNUSED_ATTRIBUTE;
8939int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
8940
8941/* authenticator */
8942{
8943size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8944ret = 0;
8945e = encode_EncryptedData(p, len, &(data)->authenticator, &l);
8946if (e) return e;
8947p -= l; len -= l; ret += l;
8948
8949e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
8950if (e) return e;
8951p -= l; len -= l; ret += l;
8952
8953ret += Top_tag_tag_oldret;
8954}
8955/* ticket */
8956{
8957size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8958ret = 0;
8959e = encode_Ticket(p, len, &(data)->ticket, &l);
8960if (e) return e;
8961p -= l; len -= l; ret += l;
8962
8963e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
8964if (e) return e;
8965p -= l; len -= l; ret += l;
8966
8967ret += Top_tag_tag_oldret;
8968}
8969/* ap-options */
8970{
8971size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8972ret = 0;
8973e = encode_APOptions(p, len, &(data)->ap_options, &l);
8974if (e) return e;
8975p -= l; len -= l; ret += l;
8976
8977e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
8978if (e) return e;
8979p -= l; len -= l; ret += l;
8980
8981ret += Top_tag_tag_oldret;
8982}
8983/* msg-type */
8984{
8985size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
8986ret = 0;
8987e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
8988if (e) return e;
8989p -= l; len -= l; ret += l;
8990
8991e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
8992if (e) return e;
8993p -= l; len -= l; ret += l;
8994
8995ret += Top_tag_tag_oldret;
8996}
8997/* pvno */
8998{
8999size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9000ret = 0;
9001e = encode_krb5int32(p, len, &(data)->pvno, &l);
9002if (e) return e;
9003p -= l; len -= l; ret += l;
9004
9005e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
9006if (e) return e;
9007p -= l; len -= l; ret += l;
9008
9009ret += Top_tag_tag_oldret;
9010}
9011e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9012if (e) return e;
9013p -= l; len -= l; ret += l;
9014
9015e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 14, &l);
9016if (e) return e;
9017p -= l; len -= l; ret += l;
9018
9019*size = ret;
9020return 0;
9021}
9022
9023int ASN1CALL
9024decode_AP_REQ(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AP_REQ *data, size_t *size)
9025{
9026size_t ret = 0;
9027size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9028int e HEIMDAL_UNUSED_ATTRIBUTE;
9029
9030memset(data, 0, sizeof(*data));
9031{
9032size_t Top_datalen, Top_oldlen;
9033Der_type Top_type;
9034e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 14, &Top_datalen, &l);
9035if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9036if(e) goto fail;
9037p += l; len -= l; ret += l;
9038Top_oldlen = len;
9039if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9040len = Top_datalen;
9041{
9042size_t Top_Tag_datalen, Top_Tag_oldlen;
9043Der_type Top_Tag_type;
9044e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
9045if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
9046if(e) goto fail;
9047p += l; len -= l; ret += l;
9048Top_Tag_oldlen = len;
9049if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9050len = Top_Tag_datalen;
9051{
9052size_t pvno_datalen, pvno_oldlen;
9053Der_type pvno_type;
9054e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
9055if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
9056if(e) goto fail;
9057p += l; len -= l; ret += l;
9058pvno_oldlen = len;
9059if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9060len = pvno_datalen;
9061e = decode_krb5int32(p, len, &(data)->pvno, &l);
9062if(e) goto fail;
9063p += l; len -= l; ret += l;
9064len = pvno_oldlen - pvno_datalen;
9065}
9066{
9067size_t msg_type_datalen, msg_type_oldlen;
9068Der_type msg_type_type;
9069e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
9070if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
9071if(e) goto fail;
9072p += l; len -= l; ret += l;
9073msg_type_oldlen = len;
9074if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9075len = msg_type_datalen;
9076e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
9077if(e) goto fail;
9078p += l; len -= l; ret += l;
9079len = msg_type_oldlen - msg_type_datalen;
9080}
9081{
9082size_t ap_options_datalen, ap_options_oldlen;
9083Der_type ap_options_type;
9084e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ap_options_type, 2, &ap_options_datalen, &l);
9085if (e == 0 && ap_options_type != CONS) { e = ASN1_BAD_ID; }
9086if(e) goto fail;
9087p += l; len -= l; ret += l;
9088ap_options_oldlen = len;
9089if (ap_options_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9090len = ap_options_datalen;
9091e = decode_APOptions(p, len, &(data)->ap_options, &l);
9092if(e) goto fail;
9093p += l; len -= l; ret += l;
9094len = ap_options_oldlen - ap_options_datalen;
9095}
9096{
9097size_t ticket_datalen, ticket_oldlen;
9098Der_type ticket_type;
9099e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_type, 3, &ticket_datalen, &l);
9100if (e == 0 && ticket_type != CONS) { e = ASN1_BAD_ID; }
9101if(e) goto fail;
9102p += l; len -= l; ret += l;
9103ticket_oldlen = len;
9104if (ticket_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9105len = ticket_datalen;
9106e = decode_Ticket(p, len, &(data)->ticket, &l);
9107if(e) goto fail;
9108p += l; len -= l; ret += l;
9109len = ticket_oldlen - ticket_datalen;
9110}
9111{
9112size_t authenticator_datalen, authenticator_oldlen;
9113Der_type authenticator_type;
9114e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authenticator_type, 4, &authenticator_datalen, &l);
9115if (e == 0 && authenticator_type != CONS) { e = ASN1_BAD_ID; }
9116if(e) goto fail;
9117p += l; len -= l; ret += l;
9118authenticator_oldlen = len;
9119if (authenticator_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9120len = authenticator_datalen;
9121e = decode_EncryptedData(p, len, &(data)->authenticator, &l);
9122if(e) goto fail;
9123p += l; len -= l; ret += l;
9124len = authenticator_oldlen - authenticator_datalen;
9125}
9126len = Top_Tag_oldlen - Top_Tag_datalen;
9127}
9128len = Top_oldlen - Top_datalen;
9129}
9130if(size) *size = ret;
9131return 0;
9132fail:
9133free_AP_REQ(data);
9134return e;
9135}
9136
9137void ASN1CALL
9138free_AP_REQ(AP_REQ *data)
9139{
9140free_krb5int32(&(data)->pvno);
9141free_MESSAGE_TYPE(&(data)->msg_type);
9142free_APOptions(&(data)->ap_options);
9143free_Ticket(&(data)->ticket);
9144free_EncryptedData(&(data)->authenticator);
9145}
9146
9147size_t ASN1CALL
9148length_AP_REQ(const AP_REQ *data)
9149{
9150size_t ret = 0;
9151{
9152size_t Top_tag_tag_oldret = ret;
9153ret = 0;
9154ret += length_krb5int32(&(data)->pvno);
9155ret += 1 + der_length_len (ret);
9156ret += Top_tag_tag_oldret;
9157}
9158{
9159size_t Top_tag_tag_oldret = ret;
9160ret = 0;
9161ret += length_MESSAGE_TYPE(&(data)->msg_type);
9162ret += 1 + der_length_len (ret);
9163ret += Top_tag_tag_oldret;
9164}
9165{
9166size_t Top_tag_tag_oldret = ret;
9167ret = 0;
9168ret += length_APOptions(&(data)->ap_options);
9169ret += 1 + der_length_len (ret);
9170ret += Top_tag_tag_oldret;
9171}
9172{
9173size_t Top_tag_tag_oldret = ret;
9174ret = 0;
9175ret += length_Ticket(&(data)->ticket);
9176ret += 1 + der_length_len (ret);
9177ret += Top_tag_tag_oldret;
9178}
9179{
9180size_t Top_tag_tag_oldret = ret;
9181ret = 0;
9182ret += length_EncryptedData(&(data)->authenticator);
9183ret += 1 + der_length_len (ret);
9184ret += Top_tag_tag_oldret;
9185}
9186ret += 1 + der_length_len (ret);
9187ret += 1 + der_length_len (ret);
9188return ret;
9189}
9190
9191int ASN1CALL
9192copy_AP_REQ(const AP_REQ *from, AP_REQ *to)
9193{
9194memset(to, 0, sizeof(*to));
9195if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
9196if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
9197if(copy_APOptions(&(from)->ap_options, &(to)->ap_options)) goto fail;
9198if(copy_Ticket(&(from)->ticket, &(to)->ticket)) goto fail;
9199if(copy_EncryptedData(&(from)->authenticator, &(to)->authenticator)) goto fail;
9200return 0;
9201fail:
9202free_AP_REQ(to);
9203return ENOMEM;
9204}
9205
9206int ASN1CALL
9207encode_AP_REP(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AP_REP *data, size_t *size)
9208{
9209size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9210size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9211int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9212
9213/* enc-part */
9214{
9215size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9216ret = 0;
9217e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
9218if (e) return e;
9219p -= l; len -= l; ret += l;
9220
9221e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
9222if (e) return e;
9223p -= l; len -= l; ret += l;
9224
9225ret += Top_tag_tag_oldret;
9226}
9227/* msg-type */
9228{
9229size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9230ret = 0;
9231e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
9232if (e) return e;
9233p -= l; len -= l; ret += l;
9234
9235e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
9236if (e) return e;
9237p -= l; len -= l; ret += l;
9238
9239ret += Top_tag_tag_oldret;
9240}
9241/* pvno */
9242{
9243size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9244ret = 0;
9245e = encode_krb5int32(p, len, &(data)->pvno, &l);
9246if (e) return e;
9247p -= l; len -= l; ret += l;
9248
9249e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
9250if (e) return e;
9251p -= l; len -= l; ret += l;
9252
9253ret += Top_tag_tag_oldret;
9254}
9255e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9256if (e) return e;
9257p -= l; len -= l; ret += l;
9258
9259e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 15, &l);
9260if (e) return e;
9261p -= l; len -= l; ret += l;
9262
9263*size = ret;
9264return 0;
9265}
9266
9267int ASN1CALL
9268decode_AP_REP(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AP_REP *data, size_t *size)
9269{
9270size_t ret = 0;
9271size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9272int e HEIMDAL_UNUSED_ATTRIBUTE;
9273
9274memset(data, 0, sizeof(*data));
9275{
9276size_t Top_datalen, Top_oldlen;
9277Der_type Top_type;
9278e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 15, &Top_datalen, &l);
9279if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9280if(e) goto fail;
9281p += l; len -= l; ret += l;
9282Top_oldlen = len;
9283if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9284len = Top_datalen;
9285{
9286size_t Top_Tag_datalen, Top_Tag_oldlen;
9287Der_type Top_Tag_type;
9288e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
9289if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
9290if(e) goto fail;
9291p += l; len -= l; ret += l;
9292Top_Tag_oldlen = len;
9293if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9294len = Top_Tag_datalen;
9295{
9296size_t pvno_datalen, pvno_oldlen;
9297Der_type pvno_type;
9298e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
9299if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
9300if(e) goto fail;
9301p += l; len -= l; ret += l;
9302pvno_oldlen = len;
9303if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9304len = pvno_datalen;
9305e = decode_krb5int32(p, len, &(data)->pvno, &l);
9306if(e) goto fail;
9307p += l; len -= l; ret += l;
9308len = pvno_oldlen - pvno_datalen;
9309}
9310{
9311size_t msg_type_datalen, msg_type_oldlen;
9312Der_type msg_type_type;
9313e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
9314if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
9315if(e) goto fail;
9316p += l; len -= l; ret += l;
9317msg_type_oldlen = len;
9318if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9319len = msg_type_datalen;
9320e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
9321if(e) goto fail;
9322p += l; len -= l; ret += l;
9323len = msg_type_oldlen - msg_type_datalen;
9324}
9325{
9326size_t enc_part_datalen, enc_part_oldlen;
9327Der_type enc_part_type;
9328e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 2, &enc_part_datalen, &l);
9329if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
9330if(e) goto fail;
9331p += l; len -= l; ret += l;
9332enc_part_oldlen = len;
9333if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9334len = enc_part_datalen;
9335e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
9336if(e) goto fail;
9337p += l; len -= l; ret += l;
9338len = enc_part_oldlen - enc_part_datalen;
9339}
9340len = Top_Tag_oldlen - Top_Tag_datalen;
9341}
9342len = Top_oldlen - Top_datalen;
9343}
9344if(size) *size = ret;
9345return 0;
9346fail:
9347free_AP_REP(data);
9348return e;
9349}
9350
9351void ASN1CALL
9352free_AP_REP(AP_REP *data)
9353{
9354free_krb5int32(&(data)->pvno);
9355free_MESSAGE_TYPE(&(data)->msg_type);
9356free_EncryptedData(&(data)->enc_part);
9357}
9358
9359size_t ASN1CALL
9360length_AP_REP(const AP_REP *data)
9361{
9362size_t ret = 0;
9363{
9364size_t Top_tag_tag_oldret = ret;
9365ret = 0;
9366ret += length_krb5int32(&(data)->pvno);
9367ret += 1 + der_length_len (ret);
9368ret += Top_tag_tag_oldret;
9369}
9370{
9371size_t Top_tag_tag_oldret = ret;
9372ret = 0;
9373ret += length_MESSAGE_TYPE(&(data)->msg_type);
9374ret += 1 + der_length_len (ret);
9375ret += Top_tag_tag_oldret;
9376}
9377{
9378size_t Top_tag_tag_oldret = ret;
9379ret = 0;
9380ret += length_EncryptedData(&(data)->enc_part);
9381ret += 1 + der_length_len (ret);
9382ret += Top_tag_tag_oldret;
9383}
9384ret += 1 + der_length_len (ret);
9385ret += 1 + der_length_len (ret);
9386return ret;
9387}
9388
9389int ASN1CALL
9390copy_AP_REP(const AP_REP *from, AP_REP *to)
9391{
9392memset(to, 0, sizeof(*to));
9393if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
9394if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
9395if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
9396return 0;
9397fail:
9398free_AP_REP(to);
9399return ENOMEM;
9400}
9401
9402int ASN1CALL
9403encode_EncAPRepPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncAPRepPart *data, size_t *size)
9404{
9405size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9406size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9407int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9408
9409/* seq-number */
9410if((data)->seq_number) {
9411size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9412ret = 0;
9413e = encode_krb5uint32(p, len, (data)->seq_number, &l);
9414if (e) return e;
9415p -= l; len -= l; ret += l;
9416
9417e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
9418if (e) return e;
9419p -= l; len -= l; ret += l;
9420
9421ret += Top_tag_tag_oldret;
9422}
9423/* subkey */
9424if((data)->subkey) {
9425size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9426ret = 0;
9427e = encode_EncryptionKey(p, len, (data)->subkey, &l);
9428if (e) return e;
9429p -= l; len -= l; ret += l;
9430
9431e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
9432if (e) return e;
9433p -= l; len -= l; ret += l;
9434
9435ret += Top_tag_tag_oldret;
9436}
9437/* cusec */
9438{
9439size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9440ret = 0;
9441e = encode_krb5int32(p, len, &(data)->cusec, &l);
9442if (e) return e;
9443p -= l; len -= l; ret += l;
9444
9445e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
9446if (e) return e;
9447p -= l; len -= l; ret += l;
9448
9449ret += Top_tag_tag_oldret;
9450}
9451/* ctime */
9452{
9453size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9454ret = 0;
9455e = encode_KerberosTime(p, len, &(data)->ctime, &l);
9456if (e) return e;
9457p -= l; len -= l; ret += l;
9458
9459e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
9460if (e) return e;
9461p -= l; len -= l; ret += l;
9462
9463ret += Top_tag_tag_oldret;
9464}
9465e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9466if (e) return e;
9467p -= l; len -= l; ret += l;
9468
9469e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 27, &l);
9470if (e) return e;
9471p -= l; len -= l; ret += l;
9472
9473*size = ret;
9474return 0;
9475}
9476
9477int ASN1CALL
9478decode_EncAPRepPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncAPRepPart *data, size_t *size)
9479{
9480size_t ret = 0;
9481size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9482int e HEIMDAL_UNUSED_ATTRIBUTE;
9483
9484memset(data, 0, sizeof(*data));
9485{
9486size_t Top_datalen, Top_oldlen;
9487Der_type Top_type;
9488e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 27, &Top_datalen, &l);
9489if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9490if(e) goto fail;
9491p += l; len -= l; ret += l;
9492Top_oldlen = len;
9493if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9494len = Top_datalen;
9495{
9496size_t Top_Tag_datalen, Top_Tag_oldlen;
9497Der_type Top_Tag_type;
9498e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
9499if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
9500if(e) goto fail;
9501p += l; len -= l; ret += l;
9502Top_Tag_oldlen = len;
9503if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9504len = Top_Tag_datalen;
9505{
9506size_t ctime_datalen, ctime_oldlen;
9507Der_type ctime_type;
9508e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ctime_type, 0, &ctime_datalen, &l);
9509if (e == 0 && ctime_type != CONS) { e = ASN1_BAD_ID; }
9510if(e) goto fail;
9511p += l; len -= l; ret += l;
9512ctime_oldlen = len;
9513if (ctime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9514len = ctime_datalen;
9515e = decode_KerberosTime(p, len, &(data)->ctime, &l);
9516if(e) goto fail;
9517p += l; len -= l; ret += l;
9518len = ctime_oldlen - ctime_datalen;
9519}
9520{
9521size_t cusec_datalen, cusec_oldlen;
9522Der_type cusec_type;
9523e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cusec_type, 1, &cusec_datalen, &l);
9524if (e == 0 && cusec_type != CONS) { e = ASN1_BAD_ID; }
9525if(e) goto fail;
9526p += l; len -= l; ret += l;
9527cusec_oldlen = len;
9528if (cusec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9529len = cusec_datalen;
9530e = decode_krb5int32(p, len, &(data)->cusec, &l);
9531if(e) goto fail;
9532p += l; len -= l; ret += l;
9533len = cusec_oldlen - cusec_datalen;
9534}
9535{
9536size_t subkey_datalen, subkey_oldlen;
9537Der_type subkey_type;
9538e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subkey_type, 2, &subkey_datalen, &l);
9539if (e == 0 && subkey_type != CONS) { e = ASN1_BAD_ID; }
9540if(e) {
9541(data)->subkey = NULL;
9542} else {
9543(data)->subkey = calloc(1, sizeof(*(data)->subkey));
9544if ((data)->subkey == NULL) { e = ENOMEM; goto fail; }
9545p += l; len -= l; ret += l;
9546subkey_oldlen = len;
9547if (subkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9548len = subkey_datalen;
9549e = decode_EncryptionKey(p, len, (data)->subkey, &l);
9550if(e) goto fail;
9551p += l; len -= l; ret += l;
9552len = subkey_oldlen - subkey_datalen;
9553}
9554}
9555{
9556size_t seq_number_datalen, seq_number_oldlen;
9557Der_type seq_number_type;
9558e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 3, &seq_number_datalen, &l);
9559if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
9560if(e) {
9561(data)->seq_number = NULL;
9562} else {
9563(data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
9564if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
9565p += l; len -= l; ret += l;
9566seq_number_oldlen = len;
9567if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9568len = seq_number_datalen;
9569e = decode_krb5uint32(p, len, (data)->seq_number, &l);
9570if(e) goto fail;
9571p += l; len -= l; ret += l;
9572len = seq_number_oldlen - seq_number_datalen;
9573}
9574}
9575len = Top_Tag_oldlen - Top_Tag_datalen;
9576}
9577len = Top_oldlen - Top_datalen;
9578}
9579if(size) *size = ret;
9580return 0;
9581fail:
9582free_EncAPRepPart(data);
9583return e;
9584}
9585
9586void ASN1CALL
9587free_EncAPRepPart(EncAPRepPart *data)
9588{
9589free_KerberosTime(&(data)->ctime);
9590free_krb5int32(&(data)->cusec);
9591if((data)->subkey) {
9592free_EncryptionKey((data)->subkey);
9593free((data)->subkey);
9594(data)->subkey = NULL;
9595}
9596if((data)->seq_number) {
9597free_krb5uint32((data)->seq_number);
9598free((data)->seq_number);
9599(data)->seq_number = NULL;
9600}
9601}
9602
9603size_t ASN1CALL
9604length_EncAPRepPart(const EncAPRepPart *data)
9605{
9606size_t ret = 0;
9607{
9608size_t Top_tag_tag_oldret = ret;
9609ret = 0;
9610ret += length_KerberosTime(&(data)->ctime);
9611ret += 1 + der_length_len (ret);
9612ret += Top_tag_tag_oldret;
9613}
9614{
9615size_t Top_tag_tag_oldret = ret;
9616ret = 0;
9617ret += length_krb5int32(&(data)->cusec);
9618ret += 1 + der_length_len (ret);
9619ret += Top_tag_tag_oldret;
9620}
9621if((data)->subkey){
9622size_t Top_tag_tag_oldret = ret;
9623ret = 0;
9624ret += length_EncryptionKey((data)->subkey);
9625ret += 1 + der_length_len (ret);
9626ret += Top_tag_tag_oldret;
9627}
9628if((data)->seq_number){
9629size_t Top_tag_tag_oldret = ret;
9630ret = 0;
9631ret += length_krb5uint32((data)->seq_number);
9632ret += 1 + der_length_len (ret);
9633ret += Top_tag_tag_oldret;
9634}
9635ret += 1 + der_length_len (ret);
9636ret += 1 + der_length_len (ret);
9637return ret;
9638}
9639
9640int ASN1CALL
9641copy_EncAPRepPart(const EncAPRepPart *from, EncAPRepPart *to)
9642{
9643memset(to, 0, sizeof(*to));
9644if(copy_KerberosTime(&(from)->ctime, &(to)->ctime)) goto fail;
9645if(copy_krb5int32(&(from)->cusec, &(to)->cusec)) goto fail;
9646if((from)->subkey) {
9647(to)->subkey = malloc(sizeof(*(to)->subkey));
9648if((to)->subkey == NULL) goto fail;
9649if(copy_EncryptionKey((from)->subkey, (to)->subkey)) goto fail;
9650}else
9651(to)->subkey = NULL;
9652if((from)->seq_number) {
9653(to)->seq_number = malloc(sizeof(*(to)->seq_number));
9654if((to)->seq_number == NULL) goto fail;
9655if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
9656}else
9657(to)->seq_number = NULL;
9658return 0;
9659fail:
9660free_EncAPRepPart(to);
9661return ENOMEM;
9662}
9663
9664int ASN1CALL
9665encode_KRB_SAFE_BODY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_SAFE_BODY *data, size_t *size)
9666{
9667size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
9668size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9669int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
9670
9671/* r-address */
9672if((data)->r_address) {
9673size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9674ret = 0;
9675e = encode_HostAddress(p, len, (data)->r_address, &l);
9676if (e) return e;
9677p -= l; len -= l; ret += l;
9678
9679e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
9680if (e) return e;
9681p -= l; len -= l; ret += l;
9682
9683ret += Top_tag_oldret;
9684}
9685/* s-address */
9686if((data)->s_address) {
9687size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9688ret = 0;
9689e = encode_HostAddress(p, len, (data)->s_address, &l);
9690if (e) return e;
9691p -= l; len -= l; ret += l;
9692
9693e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
9694if (e) return e;
9695p -= l; len -= l; ret += l;
9696
9697ret += Top_tag_oldret;
9698}
9699/* seq-number */
9700if((data)->seq_number) {
9701size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9702ret = 0;
9703e = encode_krb5uint32(p, len, (data)->seq_number, &l);
9704if (e) return e;
9705p -= l; len -= l; ret += l;
9706
9707e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
9708if (e) return e;
9709p -= l; len -= l; ret += l;
9710
9711ret += Top_tag_oldret;
9712}
9713/* usec */
9714if((data)->usec) {
9715size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9716ret = 0;
9717e = encode_krb5int32(p, len, (data)->usec, &l);
9718if (e) return e;
9719p -= l; len -= l; ret += l;
9720
9721e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
9722if (e) return e;
9723p -= l; len -= l; ret += l;
9724
9725ret += Top_tag_oldret;
9726}
9727/* timestamp */
9728if((data)->timestamp) {
9729size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9730ret = 0;
9731e = encode_KerberosTime(p, len, (data)->timestamp, &l);
9732if (e) return e;
9733p -= l; len -= l; ret += l;
9734
9735e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
9736if (e) return e;
9737p -= l; len -= l; ret += l;
9738
9739ret += Top_tag_oldret;
9740}
9741/* user-data */
9742{
9743size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
9744ret = 0;
9745e = der_put_octet_string(p, len, &(data)->user_data, &l);
9746if (e) return e;
9747p -= l; len -= l; ret += l;
9748
9749e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
9750if (e) return e;
9751p -= l; len -= l; ret += l;
9752
9753e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
9754if (e) return e;
9755p -= l; len -= l; ret += l;
9756
9757ret += Top_tag_oldret;
9758}
9759e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
9760if (e) return e;
9761p -= l; len -= l; ret += l;
9762
9763*size = ret;
9764return 0;
9765}
9766
9767int ASN1CALL
9768decode_KRB_SAFE_BODY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_SAFE_BODY *data, size_t *size)
9769{
9770size_t ret = 0;
9771size_t l HEIMDAL_UNUSED_ATTRIBUTE;
9772int e HEIMDAL_UNUSED_ATTRIBUTE;
9773
9774memset(data, 0, sizeof(*data));
9775{
9776size_t Top_datalen, Top_oldlen;
9777Der_type Top_type;
9778e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
9779if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
9780if(e) goto fail;
9781p += l; len -= l; ret += l;
9782Top_oldlen = len;
9783if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9784len = Top_datalen;
9785{
9786size_t user_data_datalen, user_data_oldlen;
9787Der_type user_data_type;
9788e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &user_data_type, 0, &user_data_datalen, &l);
9789if (e == 0 && user_data_type != CONS) { e = ASN1_BAD_ID; }
9790if(e) goto fail;
9791p += l; len -= l; ret += l;
9792user_data_oldlen = len;
9793if (user_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9794len = user_data_datalen;
9795{
9796size_t user_data_Tag_datalen, user_data_Tag_oldlen;
9797Der_type user_data_Tag_type;
9798e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &user_data_Tag_type, UT_OctetString, &user_data_Tag_datalen, &l);
9799if (e == 0 && user_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
9800if(e) goto fail;
9801p += l; len -= l; ret += l;
9802user_data_Tag_oldlen = len;
9803if (user_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9804len = user_data_Tag_datalen;
9805e = der_get_octet_string(p, len, &(data)->user_data, &l);
9806if(e) goto fail;
9807p += l; len -= l; ret += l;
9808len = user_data_Tag_oldlen - user_data_Tag_datalen;
9809}
9810len = user_data_oldlen - user_data_datalen;
9811}
9812{
9813size_t timestamp_datalen, timestamp_oldlen;
9814Der_type timestamp_type;
9815e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &timestamp_type, 1, &timestamp_datalen, &l);
9816if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
9817if(e) {
9818(data)->timestamp = NULL;
9819} else {
9820(data)->timestamp = calloc(1, sizeof(*(data)->timestamp));
9821if ((data)->timestamp == NULL) { e = ENOMEM; goto fail; }
9822p += l; len -= l; ret += l;
9823timestamp_oldlen = len;
9824if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9825len = timestamp_datalen;
9826e = decode_KerberosTime(p, len, (data)->timestamp, &l);
9827if(e) goto fail;
9828p += l; len -= l; ret += l;
9829len = timestamp_oldlen - timestamp_datalen;
9830}
9831}
9832{
9833size_t usec_datalen, usec_oldlen;
9834Der_type usec_type;
9835e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 2, &usec_datalen, &l);
9836if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
9837if(e) {
9838(data)->usec = NULL;
9839} else {
9840(data)->usec = calloc(1, sizeof(*(data)->usec));
9841if ((data)->usec == NULL) { e = ENOMEM; goto fail; }
9842p += l; len -= l; ret += l;
9843usec_oldlen = len;
9844if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9845len = usec_datalen;
9846e = decode_krb5int32(p, len, (data)->usec, &l);
9847if(e) goto fail;
9848p += l; len -= l; ret += l;
9849len = usec_oldlen - usec_datalen;
9850}
9851}
9852{
9853size_t seq_number_datalen, seq_number_oldlen;
9854Der_type seq_number_type;
9855e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 3, &seq_number_datalen, &l);
9856if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
9857if(e) {
9858(data)->seq_number = NULL;
9859} else {
9860(data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
9861if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
9862p += l; len -= l; ret += l;
9863seq_number_oldlen = len;
9864if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9865len = seq_number_datalen;
9866e = decode_krb5uint32(p, len, (data)->seq_number, &l);
9867if(e) goto fail;
9868p += l; len -= l; ret += l;
9869len = seq_number_oldlen - seq_number_datalen;
9870}
9871}
9872{
9873size_t s_address_datalen, s_address_oldlen;
9874Der_type s_address_type;
9875e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s_address_type, 4, &s_address_datalen, &l);
9876if (e == 0 && s_address_type != CONS) { e = ASN1_BAD_ID; }
9877if(e) {
9878(data)->s_address = NULL;
9879} else {
9880(data)->s_address = calloc(1, sizeof(*(data)->s_address));
9881if ((data)->s_address == NULL) { e = ENOMEM; goto fail; }
9882p += l; len -= l; ret += l;
9883s_address_oldlen = len;
9884if (s_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9885len = s_address_datalen;
9886e = decode_HostAddress(p, len, (data)->s_address, &l);
9887if(e) goto fail;
9888p += l; len -= l; ret += l;
9889len = s_address_oldlen - s_address_datalen;
9890}
9891}
9892{
9893size_t r_address_datalen, r_address_oldlen;
9894Der_type r_address_type;
9895e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &r_address_type, 5, &r_address_datalen, &l);
9896if (e == 0 && r_address_type != CONS) { e = ASN1_BAD_ID; }
9897if(e) {
9898(data)->r_address = NULL;
9899} else {
9900(data)->r_address = calloc(1, sizeof(*(data)->r_address));
9901if ((data)->r_address == NULL) { e = ENOMEM; goto fail; }
9902p += l; len -= l; ret += l;
9903r_address_oldlen = len;
9904if (r_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
9905len = r_address_datalen;
9906e = decode_HostAddress(p, len, (data)->r_address, &l);
9907if(e) goto fail;
9908p += l; len -= l; ret += l;
9909len = r_address_oldlen - r_address_datalen;
9910}
9911}
9912len = Top_oldlen - Top_datalen;
9913}
9914if(size) *size = ret;
9915return 0;
9916fail:
9917free_KRB_SAFE_BODY(data);
9918return e;
9919}
9920
9921void ASN1CALL
9922free_KRB_SAFE_BODY(KRB_SAFE_BODY *data)
9923{
9924der_free_octet_string(&(data)->user_data);
9925if((data)->timestamp) {
9926free_KerberosTime((data)->timestamp);
9927free((data)->timestamp);
9928(data)->timestamp = NULL;
9929}
9930if((data)->usec) {
9931free_krb5int32((data)->usec);
9932free((data)->usec);
9933(data)->usec = NULL;
9934}
9935if((data)->seq_number) {
9936free_krb5uint32((data)->seq_number);
9937free((data)->seq_number);
9938(data)->seq_number = NULL;
9939}
9940if((data)->s_address) {
9941free_HostAddress((data)->s_address);
9942free((data)->s_address);
9943(data)->s_address = NULL;
9944}
9945if((data)->r_address) {
9946free_HostAddress((data)->r_address);
9947free((data)->r_address);
9948(data)->r_address = NULL;
9949}
9950}
9951
9952size_t ASN1CALL
9953length_KRB_SAFE_BODY(const KRB_SAFE_BODY *data)
9954{
9955size_t ret = 0;
9956{
9957size_t Top_tag_oldret = ret;
9958ret = 0;
9959ret += der_length_octet_string(&(data)->user_data);
9960ret += 1 + der_length_len (ret);
9961ret += 1 + der_length_len (ret);
9962ret += Top_tag_oldret;
9963}
9964if((data)->timestamp){
9965size_t Top_tag_oldret = ret;
9966ret = 0;
9967ret += length_KerberosTime((data)->timestamp);
9968ret += 1 + der_length_len (ret);
9969ret += Top_tag_oldret;
9970}
9971if((data)->usec){
9972size_t Top_tag_oldret = ret;
9973ret = 0;
9974ret += length_krb5int32((data)->usec);
9975ret += 1 + der_length_len (ret);
9976ret += Top_tag_oldret;
9977}
9978if((data)->seq_number){
9979size_t Top_tag_oldret = ret;
9980ret = 0;
9981ret += length_krb5uint32((data)->seq_number);
9982ret += 1 + der_length_len (ret);
9983ret += Top_tag_oldret;
9984}
9985if((data)->s_address){
9986size_t Top_tag_oldret = ret;
9987ret = 0;
9988ret += length_HostAddress((data)->s_address);
9989ret += 1 + der_length_len (ret);
9990ret += Top_tag_oldret;
9991}
9992if((data)->r_address){
9993size_t Top_tag_oldret = ret;
9994ret = 0;
9995ret += length_HostAddress((data)->r_address);
9996ret += 1 + der_length_len (ret);
9997ret += Top_tag_oldret;
9998}
9999ret += 1 + der_length_len (ret);
10000return ret;
10001}
10002
10003int ASN1CALL
10004copy_KRB_SAFE_BODY(const KRB_SAFE_BODY *from, KRB_SAFE_BODY *to)
10005{
10006memset(to, 0, sizeof(*to));
10007if(der_copy_octet_string(&(from)->user_data, &(to)->user_data)) goto fail;
10008if((from)->timestamp) {
10009(to)->timestamp = malloc(sizeof(*(to)->timestamp));
10010if((to)->timestamp == NULL) goto fail;
10011if(copy_KerberosTime((from)->timestamp, (to)->timestamp)) goto fail;
10012}else
10013(to)->timestamp = NULL;
10014if((from)->usec) {
10015(to)->usec = malloc(sizeof(*(to)->usec));
10016if((to)->usec == NULL) goto fail;
10017if(copy_krb5int32((from)->usec, (to)->usec)) goto fail;
10018}else
10019(to)->usec = NULL;
10020if((from)->seq_number) {
10021(to)->seq_number = malloc(sizeof(*(to)->seq_number));
10022if((to)->seq_number == NULL) goto fail;
10023if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
10024}else
10025(to)->seq_number = NULL;
10026if((from)->s_address) {
10027(to)->s_address = malloc(sizeof(*(to)->s_address));
10028if((to)->s_address == NULL) goto fail;
10029if(copy_HostAddress((from)->s_address, (to)->s_address)) goto fail;
10030}else
10031(to)->s_address = NULL;
10032if((from)->r_address) {
10033(to)->r_address = malloc(sizeof(*(to)->r_address));
10034if((to)->r_address == NULL) goto fail;
10035if(copy_HostAddress((from)->r_address, (to)->r_address)) goto fail;
10036}else
10037(to)->r_address = NULL;
10038return 0;
10039fail:
10040free_KRB_SAFE_BODY(to);
10041return ENOMEM;
10042}
10043
10044int ASN1CALL
10045encode_KRB_SAFE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_SAFE *data, size_t *size)
10046{
10047size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10048size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10049int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10050
10051/* cksum */
10052{
10053size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10054ret = 0;
10055e = encode_Checksum(p, len, &(data)->cksum, &l);
10056if (e) return e;
10057p -= l; len -= l; ret += l;
10058
10059e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10060if (e) return e;
10061p -= l; len -= l; ret += l;
10062
10063ret += Top_tag_tag_oldret;
10064}
10065/* safe-body */
10066{
10067size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10068ret = 0;
10069e = encode_KRB_SAFE_BODY(p, len, &(data)->safe_body, &l);
10070if (e) return e;
10071p -= l; len -= l; ret += l;
10072
10073e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
10074if (e) return e;
10075p -= l; len -= l; ret += l;
10076
10077ret += Top_tag_tag_oldret;
10078}
10079/* msg-type */
10080{
10081size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10082ret = 0;
10083e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10084if (e) return e;
10085p -= l; len -= l; ret += l;
10086
10087e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10088if (e) return e;
10089p -= l; len -= l; ret += l;
10090
10091ret += Top_tag_tag_oldret;
10092}
10093/* pvno */
10094{
10095size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10096ret = 0;
10097e = encode_krb5int32(p, len, &(data)->pvno, &l);
10098if (e) return e;
10099p -= l; len -= l; ret += l;
10100
10101e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10102if (e) return e;
10103p -= l; len -= l; ret += l;
10104
10105ret += Top_tag_tag_oldret;
10106}
10107e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10108if (e) return e;
10109p -= l; len -= l; ret += l;
10110
10111e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 20, &l);
10112if (e) return e;
10113p -= l; len -= l; ret += l;
10114
10115*size = ret;
10116return 0;
10117}
10118
10119int ASN1CALL
10120decode_KRB_SAFE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_SAFE *data, size_t *size)
10121{
10122size_t ret = 0;
10123size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10124int e HEIMDAL_UNUSED_ATTRIBUTE;
10125
10126memset(data, 0, sizeof(*data));
10127{
10128size_t Top_datalen, Top_oldlen;
10129Der_type Top_type;
10130e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 20, &Top_datalen, &l);
10131if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10132if(e) goto fail;
10133p += l; len -= l; ret += l;
10134Top_oldlen = len;
10135if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10136len = Top_datalen;
10137{
10138size_t Top_Tag_datalen, Top_Tag_oldlen;
10139Der_type Top_Tag_type;
10140e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10141if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10142if(e) goto fail;
10143p += l; len -= l; ret += l;
10144Top_Tag_oldlen = len;
10145if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10146len = Top_Tag_datalen;
10147{
10148size_t pvno_datalen, pvno_oldlen;
10149Der_type pvno_type;
10150e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
10151if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
10152if(e) goto fail;
10153p += l; len -= l; ret += l;
10154pvno_oldlen = len;
10155if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10156len = pvno_datalen;
10157e = decode_krb5int32(p, len, &(data)->pvno, &l);
10158if(e) goto fail;
10159p += l; len -= l; ret += l;
10160len = pvno_oldlen - pvno_datalen;
10161}
10162{
10163size_t msg_type_datalen, msg_type_oldlen;
10164Der_type msg_type_type;
10165e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
10166if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
10167if(e) goto fail;
10168p += l; len -= l; ret += l;
10169msg_type_oldlen = len;
10170if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10171len = msg_type_datalen;
10172e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10173if(e) goto fail;
10174p += l; len -= l; ret += l;
10175len = msg_type_oldlen - msg_type_datalen;
10176}
10177{
10178size_t safe_body_datalen, safe_body_oldlen;
10179Der_type safe_body_type;
10180e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &safe_body_type, 2, &safe_body_datalen, &l);
10181if (e == 0 && safe_body_type != CONS) { e = ASN1_BAD_ID; }
10182if(e) goto fail;
10183p += l; len -= l; ret += l;
10184safe_body_oldlen = len;
10185if (safe_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10186len = safe_body_datalen;
10187e = decode_KRB_SAFE_BODY(p, len, &(data)->safe_body, &l);
10188if(e) goto fail;
10189p += l; len -= l; ret += l;
10190len = safe_body_oldlen - safe_body_datalen;
10191}
10192{
10193size_t cksum_datalen, cksum_oldlen;
10194Der_type cksum_type;
10195e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 3, &cksum_datalen, &l);
10196if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
10197if(e) goto fail;
10198p += l; len -= l; ret += l;
10199cksum_oldlen = len;
10200if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10201len = cksum_datalen;
10202e = decode_Checksum(p, len, &(data)->cksum, &l);
10203if(e) goto fail;
10204p += l; len -= l; ret += l;
10205len = cksum_oldlen - cksum_datalen;
10206}
10207len = Top_Tag_oldlen - Top_Tag_datalen;
10208}
10209len = Top_oldlen - Top_datalen;
10210}
10211if(size) *size = ret;
10212return 0;
10213fail:
10214free_KRB_SAFE(data);
10215return e;
10216}
10217
10218void ASN1CALL
10219free_KRB_SAFE(KRB_SAFE *data)
10220{
10221free_krb5int32(&(data)->pvno);
10222free_MESSAGE_TYPE(&(data)->msg_type);
10223free_KRB_SAFE_BODY(&(data)->safe_body);
10224free_Checksum(&(data)->cksum);
10225}
10226
10227size_t ASN1CALL
10228length_KRB_SAFE(const KRB_SAFE *data)
10229{
10230size_t ret = 0;
10231{
10232size_t Top_tag_tag_oldret = ret;
10233ret = 0;
10234ret += length_krb5int32(&(data)->pvno);
10235ret += 1 + der_length_len (ret);
10236ret += Top_tag_tag_oldret;
10237}
10238{
10239size_t Top_tag_tag_oldret = ret;
10240ret = 0;
10241ret += length_MESSAGE_TYPE(&(data)->msg_type);
10242ret += 1 + der_length_len (ret);
10243ret += Top_tag_tag_oldret;
10244}
10245{
10246size_t Top_tag_tag_oldret = ret;
10247ret = 0;
10248ret += length_KRB_SAFE_BODY(&(data)->safe_body);
10249ret += 1 + der_length_len (ret);
10250ret += Top_tag_tag_oldret;
10251}
10252{
10253size_t Top_tag_tag_oldret = ret;
10254ret = 0;
10255ret += length_Checksum(&(data)->cksum);
10256ret += 1 + der_length_len (ret);
10257ret += Top_tag_tag_oldret;
10258}
10259ret += 1 + der_length_len (ret);
10260ret += 1 + der_length_len (ret);
10261return ret;
10262}
10263
10264int ASN1CALL
10265copy_KRB_SAFE(const KRB_SAFE *from, KRB_SAFE *to)
10266{
10267memset(to, 0, sizeof(*to));
10268if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
10269if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
10270if(copy_KRB_SAFE_BODY(&(from)->safe_body, &(to)->safe_body)) goto fail;
10271if(copy_Checksum(&(from)->cksum, &(to)->cksum)) goto fail;
10272return 0;
10273fail:
10274free_KRB_SAFE(to);
10275return ENOMEM;
10276}
10277
10278int ASN1CALL
10279encode_KRB_PRIV(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_PRIV *data, size_t *size)
10280{
10281size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10282size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10283int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10284
10285/* enc-part */
10286{
10287size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10288ret = 0;
10289e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
10290if (e) return e;
10291p -= l; len -= l; ret += l;
10292
10293e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10294if (e) return e;
10295p -= l; len -= l; ret += l;
10296
10297ret += Top_tag_tag_oldret;
10298}
10299/* msg-type */
10300{
10301size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10302ret = 0;
10303e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10304if (e) return e;
10305p -= l; len -= l; ret += l;
10306
10307e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10308if (e) return e;
10309p -= l; len -= l; ret += l;
10310
10311ret += Top_tag_tag_oldret;
10312}
10313/* pvno */
10314{
10315size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10316ret = 0;
10317e = encode_krb5int32(p, len, &(data)->pvno, &l);
10318if (e) return e;
10319p -= l; len -= l; ret += l;
10320
10321e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10322if (e) return e;
10323p -= l; len -= l; ret += l;
10324
10325ret += Top_tag_tag_oldret;
10326}
10327e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10328if (e) return e;
10329p -= l; len -= l; ret += l;
10330
10331e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 21, &l);
10332if (e) return e;
10333p -= l; len -= l; ret += l;
10334
10335*size = ret;
10336return 0;
10337}
10338
10339int ASN1CALL
10340decode_KRB_PRIV(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_PRIV *data, size_t *size)
10341{
10342size_t ret = 0;
10343size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10344int e HEIMDAL_UNUSED_ATTRIBUTE;
10345
10346memset(data, 0, sizeof(*data));
10347{
10348size_t Top_datalen, Top_oldlen;
10349Der_type Top_type;
10350e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 21, &Top_datalen, &l);
10351if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10352if(e) goto fail;
10353p += l; len -= l; ret += l;
10354Top_oldlen = len;
10355if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10356len = Top_datalen;
10357{
10358size_t Top_Tag_datalen, Top_Tag_oldlen;
10359Der_type Top_Tag_type;
10360e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10361if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10362if(e) goto fail;
10363p += l; len -= l; ret += l;
10364Top_Tag_oldlen = len;
10365if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10366len = Top_Tag_datalen;
10367{
10368size_t pvno_datalen, pvno_oldlen;
10369Der_type pvno_type;
10370e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
10371if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
10372if(e) goto fail;
10373p += l; len -= l; ret += l;
10374pvno_oldlen = len;
10375if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10376len = pvno_datalen;
10377e = decode_krb5int32(p, len, &(data)->pvno, &l);
10378if(e) goto fail;
10379p += l; len -= l; ret += l;
10380len = pvno_oldlen - pvno_datalen;
10381}
10382{
10383size_t msg_type_datalen, msg_type_oldlen;
10384Der_type msg_type_type;
10385e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
10386if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
10387if(e) goto fail;
10388p += l; len -= l; ret += l;
10389msg_type_oldlen = len;
10390if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10391len = msg_type_datalen;
10392e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10393if(e) goto fail;
10394p += l; len -= l; ret += l;
10395len = msg_type_oldlen - msg_type_datalen;
10396}
10397{
10398size_t enc_part_datalen, enc_part_oldlen;
10399Der_type enc_part_type;
10400e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 3, &enc_part_datalen, &l);
10401if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
10402if(e) goto fail;
10403p += l; len -= l; ret += l;
10404enc_part_oldlen = len;
10405if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10406len = enc_part_datalen;
10407e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
10408if(e) goto fail;
10409p += l; len -= l; ret += l;
10410len = enc_part_oldlen - enc_part_datalen;
10411}
10412len = Top_Tag_oldlen - Top_Tag_datalen;
10413}
10414len = Top_oldlen - Top_datalen;
10415}
10416if(size) *size = ret;
10417return 0;
10418fail:
10419free_KRB_PRIV(data);
10420return e;
10421}
10422
10423void ASN1CALL
10424free_KRB_PRIV(KRB_PRIV *data)
10425{
10426free_krb5int32(&(data)->pvno);
10427free_MESSAGE_TYPE(&(data)->msg_type);
10428free_EncryptedData(&(data)->enc_part);
10429}
10430
10431size_t ASN1CALL
10432length_KRB_PRIV(const KRB_PRIV *data)
10433{
10434size_t ret = 0;
10435{
10436size_t Top_tag_tag_oldret = ret;
10437ret = 0;
10438ret += length_krb5int32(&(data)->pvno);
10439ret += 1 + der_length_len (ret);
10440ret += Top_tag_tag_oldret;
10441}
10442{
10443size_t Top_tag_tag_oldret = ret;
10444ret = 0;
10445ret += length_MESSAGE_TYPE(&(data)->msg_type);
10446ret += 1 + der_length_len (ret);
10447ret += Top_tag_tag_oldret;
10448}
10449{
10450size_t Top_tag_tag_oldret = ret;
10451ret = 0;
10452ret += length_EncryptedData(&(data)->enc_part);
10453ret += 1 + der_length_len (ret);
10454ret += Top_tag_tag_oldret;
10455}
10456ret += 1 + der_length_len (ret);
10457ret += 1 + der_length_len (ret);
10458return ret;
10459}
10460
10461int ASN1CALL
10462copy_KRB_PRIV(const KRB_PRIV *from, KRB_PRIV *to)
10463{
10464memset(to, 0, sizeof(*to));
10465if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
10466if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
10467if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
10468return 0;
10469fail:
10470free_KRB_PRIV(to);
10471return ENOMEM;
10472}
10473
10474int ASN1CALL
10475encode_EncKrbPrivPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncKrbPrivPart *data, size_t *size)
10476{
10477size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10478size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10479int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10480
10481/* r-address */
10482if((data)->r_address) {
10483size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10484ret = 0;
10485e = encode_HostAddress(p, len, (data)->r_address, &l);
10486if (e) return e;
10487p -= l; len -= l; ret += l;
10488
10489e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
10490if (e) return e;
10491p -= l; len -= l; ret += l;
10492
10493ret += Top_tag_tag_oldret;
10494}
10495/* s-address */
10496if((data)->s_address) {
10497size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10498ret = 0;
10499e = encode_HostAddress(p, len, (data)->s_address, &l);
10500if (e) return e;
10501p -= l; len -= l; ret += l;
10502
10503e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
10504if (e) return e;
10505p -= l; len -= l; ret += l;
10506
10507ret += Top_tag_tag_oldret;
10508}
10509/* seq-number */
10510if((data)->seq_number) {
10511size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10512ret = 0;
10513e = encode_krb5uint32(p, len, (data)->seq_number, &l);
10514if (e) return e;
10515p -= l; len -= l; ret += l;
10516
10517e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10518if (e) return e;
10519p -= l; len -= l; ret += l;
10520
10521ret += Top_tag_tag_oldret;
10522}
10523/* usec */
10524if((data)->usec) {
10525size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10526ret = 0;
10527e = encode_krb5int32(p, len, (data)->usec, &l);
10528if (e) return e;
10529p -= l; len -= l; ret += l;
10530
10531e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
10532if (e) return e;
10533p -= l; len -= l; ret += l;
10534
10535ret += Top_tag_tag_oldret;
10536}
10537/* timestamp */
10538if((data)->timestamp) {
10539size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10540ret = 0;
10541e = encode_KerberosTime(p, len, (data)->timestamp, &l);
10542if (e) return e;
10543p -= l; len -= l; ret += l;
10544
10545e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10546if (e) return e;
10547p -= l; len -= l; ret += l;
10548
10549ret += Top_tag_tag_oldret;
10550}
10551/* user-data */
10552{
10553size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10554ret = 0;
10555e = der_put_octet_string(p, len, &(data)->user_data, &l);
10556if (e) return e;
10557p -= l; len -= l; ret += l;
10558
10559e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
10560if (e) return e;
10561p -= l; len -= l; ret += l;
10562
10563e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10564if (e) return e;
10565p -= l; len -= l; ret += l;
10566
10567ret += Top_tag_tag_oldret;
10568}
10569e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10570if (e) return e;
10571p -= l; len -= l; ret += l;
10572
10573e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 28, &l);
10574if (e) return e;
10575p -= l; len -= l; ret += l;
10576
10577*size = ret;
10578return 0;
10579}
10580
10581int ASN1CALL
10582decode_EncKrbPrivPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncKrbPrivPart *data, size_t *size)
10583{
10584size_t ret = 0;
10585size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10586int e HEIMDAL_UNUSED_ATTRIBUTE;
10587
10588memset(data, 0, sizeof(*data));
10589{
10590size_t Top_datalen, Top_oldlen;
10591Der_type Top_type;
10592e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 28, &Top_datalen, &l);
10593if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10594if(e) goto fail;
10595p += l; len -= l; ret += l;
10596Top_oldlen = len;
10597if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10598len = Top_datalen;
10599{
10600size_t Top_Tag_datalen, Top_Tag_oldlen;
10601Der_type Top_Tag_type;
10602e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10603if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10604if(e) goto fail;
10605p += l; len -= l; ret += l;
10606Top_Tag_oldlen = len;
10607if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10608len = Top_Tag_datalen;
10609{
10610size_t user_data_datalen, user_data_oldlen;
10611Der_type user_data_type;
10612e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &user_data_type, 0, &user_data_datalen, &l);
10613if (e == 0 && user_data_type != CONS) { e = ASN1_BAD_ID; }
10614if(e) goto fail;
10615p += l; len -= l; ret += l;
10616user_data_oldlen = len;
10617if (user_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10618len = user_data_datalen;
10619{
10620size_t user_data_Tag_datalen, user_data_Tag_oldlen;
10621Der_type user_data_Tag_type;
10622e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &user_data_Tag_type, UT_OctetString, &user_data_Tag_datalen, &l);
10623if (e == 0 && user_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
10624if(e) goto fail;
10625p += l; len -= l; ret += l;
10626user_data_Tag_oldlen = len;
10627if (user_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10628len = user_data_Tag_datalen;
10629e = der_get_octet_string(p, len, &(data)->user_data, &l);
10630if(e) goto fail;
10631p += l; len -= l; ret += l;
10632len = user_data_Tag_oldlen - user_data_Tag_datalen;
10633}
10634len = user_data_oldlen - user_data_datalen;
10635}
10636{
10637size_t timestamp_datalen, timestamp_oldlen;
10638Der_type timestamp_type;
10639e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &timestamp_type, 1, &timestamp_datalen, &l);
10640if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
10641if(e) {
10642(data)->timestamp = NULL;
10643} else {
10644(data)->timestamp = calloc(1, sizeof(*(data)->timestamp));
10645if ((data)->timestamp == NULL) { e = ENOMEM; goto fail; }
10646p += l; len -= l; ret += l;
10647timestamp_oldlen = len;
10648if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10649len = timestamp_datalen;
10650e = decode_KerberosTime(p, len, (data)->timestamp, &l);
10651if(e) goto fail;
10652p += l; len -= l; ret += l;
10653len = timestamp_oldlen - timestamp_datalen;
10654}
10655}
10656{
10657size_t usec_datalen, usec_oldlen;
10658Der_type usec_type;
10659e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 2, &usec_datalen, &l);
10660if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
10661if(e) {
10662(data)->usec = NULL;
10663} else {
10664(data)->usec = calloc(1, sizeof(*(data)->usec));
10665if ((data)->usec == NULL) { e = ENOMEM; goto fail; }
10666p += l; len -= l; ret += l;
10667usec_oldlen = len;
10668if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10669len = usec_datalen;
10670e = decode_krb5int32(p, len, (data)->usec, &l);
10671if(e) goto fail;
10672p += l; len -= l; ret += l;
10673len = usec_oldlen - usec_datalen;
10674}
10675}
10676{
10677size_t seq_number_datalen, seq_number_oldlen;
10678Der_type seq_number_type;
10679e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &seq_number_type, 3, &seq_number_datalen, &l);
10680if (e == 0 && seq_number_type != CONS) { e = ASN1_BAD_ID; }
10681if(e) {
10682(data)->seq_number = NULL;
10683} else {
10684(data)->seq_number = calloc(1, sizeof(*(data)->seq_number));
10685if ((data)->seq_number == NULL) { e = ENOMEM; goto fail; }
10686p += l; len -= l; ret += l;
10687seq_number_oldlen = len;
10688if (seq_number_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10689len = seq_number_datalen;
10690e = decode_krb5uint32(p, len, (data)->seq_number, &l);
10691if(e) goto fail;
10692p += l; len -= l; ret += l;
10693len = seq_number_oldlen - seq_number_datalen;
10694}
10695}
10696{
10697size_t s_address_datalen, s_address_oldlen;
10698Der_type s_address_type;
10699e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s_address_type, 4, &s_address_datalen, &l);
10700if (e == 0 && s_address_type != CONS) { e = ASN1_BAD_ID; }
10701if(e) {
10702(data)->s_address = NULL;
10703} else {
10704(data)->s_address = calloc(1, sizeof(*(data)->s_address));
10705if ((data)->s_address == NULL) { e = ENOMEM; goto fail; }
10706p += l; len -= l; ret += l;
10707s_address_oldlen = len;
10708if (s_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10709len = s_address_datalen;
10710e = decode_HostAddress(p, len, (data)->s_address, &l);
10711if(e) goto fail;
10712p += l; len -= l; ret += l;
10713len = s_address_oldlen - s_address_datalen;
10714}
10715}
10716{
10717size_t r_address_datalen, r_address_oldlen;
10718Der_type r_address_type;
10719e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &r_address_type, 5, &r_address_datalen, &l);
10720if (e == 0 && r_address_type != CONS) { e = ASN1_BAD_ID; }
10721if(e) {
10722(data)->r_address = NULL;
10723} else {
10724(data)->r_address = calloc(1, sizeof(*(data)->r_address));
10725if ((data)->r_address == NULL) { e = ENOMEM; goto fail; }
10726p += l; len -= l; ret += l;
10727r_address_oldlen = len;
10728if (r_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10729len = r_address_datalen;
10730e = decode_HostAddress(p, len, (data)->r_address, &l);
10731if(e) goto fail;
10732p += l; len -= l; ret += l;
10733len = r_address_oldlen - r_address_datalen;
10734}
10735}
10736len = Top_Tag_oldlen - Top_Tag_datalen;
10737}
10738len = Top_oldlen - Top_datalen;
10739}
10740if(size) *size = ret;
10741return 0;
10742fail:
10743free_EncKrbPrivPart(data);
10744return e;
10745}
10746
10747void ASN1CALL
10748free_EncKrbPrivPart(EncKrbPrivPart *data)
10749{
10750der_free_octet_string(&(data)->user_data);
10751if((data)->timestamp) {
10752free_KerberosTime((data)->timestamp);
10753free((data)->timestamp);
10754(data)->timestamp = NULL;
10755}
10756if((data)->usec) {
10757free_krb5int32((data)->usec);
10758free((data)->usec);
10759(data)->usec = NULL;
10760}
10761if((data)->seq_number) {
10762free_krb5uint32((data)->seq_number);
10763free((data)->seq_number);
10764(data)->seq_number = NULL;
10765}
10766if((data)->s_address) {
10767free_HostAddress((data)->s_address);
10768free((data)->s_address);
10769(data)->s_address = NULL;
10770}
10771if((data)->r_address) {
10772free_HostAddress((data)->r_address);
10773free((data)->r_address);
10774(data)->r_address = NULL;
10775}
10776}
10777
10778size_t ASN1CALL
10779length_EncKrbPrivPart(const EncKrbPrivPart *data)
10780{
10781size_t ret = 0;
10782{
10783size_t Top_tag_tag_oldret = ret;
10784ret = 0;
10785ret += der_length_octet_string(&(data)->user_data);
10786ret += 1 + der_length_len (ret);
10787ret += 1 + der_length_len (ret);
10788ret += Top_tag_tag_oldret;
10789}
10790if((data)->timestamp){
10791size_t Top_tag_tag_oldret = ret;
10792ret = 0;
10793ret += length_KerberosTime((data)->timestamp);
10794ret += 1 + der_length_len (ret);
10795ret += Top_tag_tag_oldret;
10796}
10797if((data)->usec){
10798size_t Top_tag_tag_oldret = ret;
10799ret = 0;
10800ret += length_krb5int32((data)->usec);
10801ret += 1 + der_length_len (ret);
10802ret += Top_tag_tag_oldret;
10803}
10804if((data)->seq_number){
10805size_t Top_tag_tag_oldret = ret;
10806ret = 0;
10807ret += length_krb5uint32((data)->seq_number);
10808ret += 1 + der_length_len (ret);
10809ret += Top_tag_tag_oldret;
10810}
10811if((data)->s_address){
10812size_t Top_tag_tag_oldret = ret;
10813ret = 0;
10814ret += length_HostAddress((data)->s_address);
10815ret += 1 + der_length_len (ret);
10816ret += Top_tag_tag_oldret;
10817}
10818if((data)->r_address){
10819size_t Top_tag_tag_oldret = ret;
10820ret = 0;
10821ret += length_HostAddress((data)->r_address);
10822ret += 1 + der_length_len (ret);
10823ret += Top_tag_tag_oldret;
10824}
10825ret += 1 + der_length_len (ret);
10826ret += 1 + der_length_len (ret);
10827return ret;
10828}
10829
10830int ASN1CALL
10831copy_EncKrbPrivPart(const EncKrbPrivPart *from, EncKrbPrivPart *to)
10832{
10833memset(to, 0, sizeof(*to));
10834if(der_copy_octet_string(&(from)->user_data, &(to)->user_data)) goto fail;
10835if((from)->timestamp) {
10836(to)->timestamp = malloc(sizeof(*(to)->timestamp));
10837if((to)->timestamp == NULL) goto fail;
10838if(copy_KerberosTime((from)->timestamp, (to)->timestamp)) goto fail;
10839}else
10840(to)->timestamp = NULL;
10841if((from)->usec) {
10842(to)->usec = malloc(sizeof(*(to)->usec));
10843if((to)->usec == NULL) goto fail;
10844if(copy_krb5int32((from)->usec, (to)->usec)) goto fail;
10845}else
10846(to)->usec = NULL;
10847if((from)->seq_number) {
10848(to)->seq_number = malloc(sizeof(*(to)->seq_number));
10849if((to)->seq_number == NULL) goto fail;
10850if(copy_krb5uint32((from)->seq_number, (to)->seq_number)) goto fail;
10851}else
10852(to)->seq_number = NULL;
10853if((from)->s_address) {
10854(to)->s_address = malloc(sizeof(*(to)->s_address));
10855if((to)->s_address == NULL) goto fail;
10856if(copy_HostAddress((from)->s_address, (to)->s_address)) goto fail;
10857}else
10858(to)->s_address = NULL;
10859if((from)->r_address) {
10860(to)->r_address = malloc(sizeof(*(to)->r_address));
10861if((to)->r_address == NULL) goto fail;
10862if(copy_HostAddress((from)->r_address, (to)->r_address)) goto fail;
10863}else
10864(to)->r_address = NULL;
10865return 0;
10866fail:
10867free_EncKrbPrivPart(to);
10868return ENOMEM;
10869}
10870
10871int ASN1CALL
10872encode_KRB_CRED(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_CRED *data, size_t *size)
10873{
10874size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
10875size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10876int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
10877
10878/* enc-part */
10879{
10880size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10881ret = 0;
10882e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
10883if (e) return e;
10884p -= l; len -= l; ret += l;
10885
10886e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
10887if (e) return e;
10888p -= l; len -= l; ret += l;
10889
10890ret += Top_tag_tag_oldret;
10891}
10892/* tickets */
10893{
10894size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10895ret = 0;
10896for(i = (int)(&(data)->tickets)->len - 1; i >= 0; --i) {
10897size_t tickets_tag_tag_for_oldret = ret;
10898ret = 0;
10899e = encode_Ticket(p, len, &(&(data)->tickets)->val[i], &l);
10900if (e) return e;
10901p -= l; len -= l; ret += l;
10902
10903ret += tickets_tag_tag_for_oldret;
10904}
10905e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10906if (e) return e;
10907p -= l; len -= l; ret += l;
10908
10909e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
10910if (e) return e;
10911p -= l; len -= l; ret += l;
10912
10913ret += Top_tag_tag_oldret;
10914}
10915/* msg-type */
10916{
10917size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10918ret = 0;
10919e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
10920if (e) return e;
10921p -= l; len -= l; ret += l;
10922
10923e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
10924if (e) return e;
10925p -= l; len -= l; ret += l;
10926
10927ret += Top_tag_tag_oldret;
10928}
10929/* pvno */
10930{
10931size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
10932ret = 0;
10933e = encode_krb5int32(p, len, &(data)->pvno, &l);
10934if (e) return e;
10935p -= l; len -= l; ret += l;
10936
10937e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
10938if (e) return e;
10939p -= l; len -= l; ret += l;
10940
10941ret += Top_tag_tag_oldret;
10942}
10943e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
10944if (e) return e;
10945p -= l; len -= l; ret += l;
10946
10947e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 22, &l);
10948if (e) return e;
10949p -= l; len -= l; ret += l;
10950
10951*size = ret;
10952return 0;
10953}
10954
10955int ASN1CALL
10956decode_KRB_CRED(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_CRED *data, size_t *size)
10957{
10958size_t ret = 0;
10959size_t l HEIMDAL_UNUSED_ATTRIBUTE;
10960int e HEIMDAL_UNUSED_ATTRIBUTE;
10961
10962memset(data, 0, sizeof(*data));
10963{
10964size_t Top_datalen, Top_oldlen;
10965Der_type Top_type;
10966e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 22, &Top_datalen, &l);
10967if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
10968if(e) goto fail;
10969p += l; len -= l; ret += l;
10970Top_oldlen = len;
10971if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10972len = Top_datalen;
10973{
10974size_t Top_Tag_datalen, Top_Tag_oldlen;
10975Der_type Top_Tag_type;
10976e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
10977if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
10978if(e) goto fail;
10979p += l; len -= l; ret += l;
10980Top_Tag_oldlen = len;
10981if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10982len = Top_Tag_datalen;
10983{
10984size_t pvno_datalen, pvno_oldlen;
10985Der_type pvno_type;
10986e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
10987if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
10988if(e) goto fail;
10989p += l; len -= l; ret += l;
10990pvno_oldlen = len;
10991if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
10992len = pvno_datalen;
10993e = decode_krb5int32(p, len, &(data)->pvno, &l);
10994if(e) goto fail;
10995p += l; len -= l; ret += l;
10996len = pvno_oldlen - pvno_datalen;
10997}
10998{
10999size_t msg_type_datalen, msg_type_oldlen;
11000Der_type msg_type_type;
11001e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
11002if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
11003if(e) goto fail;
11004p += l; len -= l; ret += l;
11005msg_type_oldlen = len;
11006if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11007len = msg_type_datalen;
11008e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
11009if(e) goto fail;
11010p += l; len -= l; ret += l;
11011len = msg_type_oldlen - msg_type_datalen;
11012}
11013{
11014size_t tickets_datalen, tickets_oldlen;
11015Der_type tickets_type;
11016e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &tickets_type, 2, &tickets_datalen, &l);
11017if (e == 0 && tickets_type != CONS) { e = ASN1_BAD_ID; }
11018if(e) goto fail;
11019p += l; len -= l; ret += l;
11020tickets_oldlen = len;
11021if (tickets_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11022len = tickets_datalen;
11023{
11024size_t tickets_Tag_datalen, tickets_Tag_oldlen;
11025Der_type tickets_Tag_type;
11026e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &tickets_Tag_type, UT_Sequence, &tickets_Tag_datalen, &l);
11027if (e == 0 && tickets_Tag_type != CONS) { e = ASN1_BAD_ID; }
11028if(e) goto fail;
11029p += l; len -= l; ret += l;
11030tickets_Tag_oldlen = len;
11031if (tickets_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11032len = tickets_Tag_datalen;
11033{
11034size_t tickets_Tag_Tag_origlen = len;
11035size_t tickets_Tag_Tag_oldret = ret;
11036size_t tickets_Tag_Tag_olen = 0;
11037void *tickets_Tag_Tag_tmp;
11038ret = 0;
11039(&(data)->tickets)->len = 0;
11040(&(data)->tickets)->val = NULL;
11041while(ret < tickets_Tag_Tag_origlen) {
11042size_t tickets_Tag_Tag_nlen = tickets_Tag_Tag_olen + sizeof(*((&(data)->tickets)->val));
11043if (tickets_Tag_Tag_olen > tickets_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
11044tickets_Tag_Tag_olen = tickets_Tag_Tag_nlen;
11045tickets_Tag_Tag_tmp = realloc((&(data)->tickets)->val, tickets_Tag_Tag_olen);
11046if (tickets_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
11047(&(data)->tickets)->val = tickets_Tag_Tag_tmp;
11048e = decode_Ticket(p, len, &(&(data)->tickets)->val[(&(data)->tickets)->len], &l);
11049if(e) goto fail;
11050p += l; len -= l; ret += l;
11051(&(data)->tickets)->len++;
11052len = tickets_Tag_Tag_origlen - ret;
11053}
11054ret += tickets_Tag_Tag_oldret;
11055}
11056len = tickets_Tag_oldlen - tickets_Tag_datalen;
11057}
11058len = tickets_oldlen - tickets_datalen;
11059}
11060{
11061size_t enc_part_datalen, enc_part_oldlen;
11062Der_type enc_part_type;
11063e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_part_type, 3, &enc_part_datalen, &l);
11064if (e == 0 && enc_part_type != CONS) { e = ASN1_BAD_ID; }
11065if(e) goto fail;
11066p += l; len -= l; ret += l;
11067enc_part_oldlen = len;
11068if (enc_part_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11069len = enc_part_datalen;
11070e = decode_EncryptedData(p, len, &(data)->enc_part, &l);
11071if(e) goto fail;
11072p += l; len -= l; ret += l;
11073len = enc_part_oldlen - enc_part_datalen;
11074}
11075len = Top_Tag_oldlen - Top_Tag_datalen;
11076}
11077len = Top_oldlen - Top_datalen;
11078}
11079if(size) *size = ret;
11080return 0;
11081fail:
11082free_KRB_CRED(data);
11083return e;
11084}
11085
11086void ASN1CALL
11087free_KRB_CRED(KRB_CRED *data)
11088{
11089free_krb5int32(&(data)->pvno);
11090free_MESSAGE_TYPE(&(data)->msg_type);
11091while((&(data)->tickets)->len){
11092free_Ticket(&(&(data)->tickets)->val[(&(data)->tickets)->len-1]);
11093(&(data)->tickets)->len--;
11094}
11095free((&(data)->tickets)->val);
11096(&(data)->tickets)->val = NULL;
11097free_EncryptedData(&(data)->enc_part);
11098}
11099
11100size_t ASN1CALL
11101length_KRB_CRED(const KRB_CRED *data)
11102{
11103size_t ret = 0;
11104{
11105size_t Top_tag_tag_oldret = ret;
11106ret = 0;
11107ret += length_krb5int32(&(data)->pvno);
11108ret += 1 + der_length_len (ret);
11109ret += Top_tag_tag_oldret;
11110}
11111{
11112size_t Top_tag_tag_oldret = ret;
11113ret = 0;
11114ret += length_MESSAGE_TYPE(&(data)->msg_type);
11115ret += 1 + der_length_len (ret);
11116ret += Top_tag_tag_oldret;
11117}
11118{
11119size_t Top_tag_tag_oldret = ret;
11120ret = 0;
11121{
11122size_t tickets_tag_tag_oldret = ret;
11123unsigned int n_tickets_tag_tag;
11124ret = 0;
11125for(n_tickets_tag_tag = (&(data)->tickets)->len; n_tickets_tag_tag > 0; --n_tickets_tag_tag){
11126size_t tickets_tag_tag_for_oldret = ret;
11127ret = 0;
11128ret += length_Ticket(&(&(data)->tickets)->val[n_tickets_tag_tag - 1]);
11129ret += tickets_tag_tag_for_oldret;
11130}
11131ret += tickets_tag_tag_oldret;
11132}
11133ret += 1 + der_length_len (ret);
11134ret += 1 + der_length_len (ret);
11135ret += Top_tag_tag_oldret;
11136}
11137{
11138size_t Top_tag_tag_oldret = ret;
11139ret = 0;
11140ret += length_EncryptedData(&(data)->enc_part);
11141ret += 1 + der_length_len (ret);
11142ret += Top_tag_tag_oldret;
11143}
11144ret += 1 + der_length_len (ret);
11145ret += 1 + der_length_len (ret);
11146return ret;
11147}
11148
11149int ASN1CALL
11150copy_KRB_CRED(const KRB_CRED *from, KRB_CRED *to)
11151{
11152memset(to, 0, sizeof(*to));
11153if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
11154if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
11155if(((&(to)->tickets)->val = malloc((&(from)->tickets)->len * sizeof(*(&(to)->tickets)->val))) == NULL && (&(from)->tickets)->len != 0)
11156goto fail;
11157for((&(to)->tickets)->len = 0; (&(to)->tickets)->len < (&(from)->tickets)->len; (&(to)->tickets)->len++){
11158if(copy_Ticket(&(&(from)->tickets)->val[(&(to)->tickets)->len], &(&(to)->tickets)->val[(&(to)->tickets)->len])) goto fail;
11159}
11160if(copy_EncryptedData(&(from)->enc_part, &(to)->enc_part)) goto fail;
11161return 0;
11162fail:
11163free_KRB_CRED(to);
11164return ENOMEM;
11165}
11166
11167int ASN1CALL
11168encode_KrbCredInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbCredInfo *data, size_t *size)
11169{
11170size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
11171size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11172int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
11173
11174/* caddr */
11175if((data)->caddr) {
11176size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11177ret = 0;
11178e = encode_HostAddresses(p, len, (data)->caddr, &l);
11179if (e) return e;
11180p -= l; len -= l; ret += l;
11181
11182e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
11183if (e) return e;
11184p -= l; len -= l; ret += l;
11185
11186ret += Top_tag_oldret;
11187}
11188/* sname */
11189if((data)->sname) {
11190size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11191ret = 0;
11192e = encode_PrincipalName(p, len, (data)->sname, &l);
11193if (e) return e;
11194p -= l; len -= l; ret += l;
11195
11196e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
11197if (e) return e;
11198p -= l; len -= l; ret += l;
11199
11200ret += Top_tag_oldret;
11201}
11202/* srealm */
11203if((data)->srealm) {
11204size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11205ret = 0;
11206e = encode_Realm(p, len, (data)->srealm, &l);
11207if (e) return e;
11208p -= l; len -= l; ret += l;
11209
11210e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
11211if (e) return e;
11212p -= l; len -= l; ret += l;
11213
11214ret += Top_tag_oldret;
11215}
11216/* renew-till */
11217if((data)->renew_till) {
11218size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11219ret = 0;
11220e = encode_KerberosTime(p, len, (data)->renew_till, &l);
11221if (e) return e;
11222p -= l; len -= l; ret += l;
11223
11224e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
11225if (e) return e;
11226p -= l; len -= l; ret += l;
11227
11228ret += Top_tag_oldret;
11229}
11230/* endtime */
11231if((data)->endtime) {
11232size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11233ret = 0;
11234e = encode_KerberosTime(p, len, (data)->endtime, &l);
11235if (e) return e;
11236p -= l; len -= l; ret += l;
11237
11238e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
11239if (e) return e;
11240p -= l; len -= l; ret += l;
11241
11242ret += Top_tag_oldret;
11243}
11244/* starttime */
11245if((data)->starttime) {
11246size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11247ret = 0;
11248e = encode_KerberosTime(p, len, (data)->starttime, &l);
11249if (e) return e;
11250p -= l; len -= l; ret += l;
11251
11252e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
11253if (e) return e;
11254p -= l; len -= l; ret += l;
11255
11256ret += Top_tag_oldret;
11257}
11258/* authtime */
11259if((data)->authtime) {
11260size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11261ret = 0;
11262e = encode_KerberosTime(p, len, (data)->authtime, &l);
11263if (e) return e;
11264p -= l; len -= l; ret += l;
11265
11266e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
11267if (e) return e;
11268p -= l; len -= l; ret += l;
11269
11270ret += Top_tag_oldret;
11271}
11272/* flags */
11273if((data)->flags) {
11274size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11275ret = 0;
11276e = encode_TicketFlags(p, len, (data)->flags, &l);
11277if (e) return e;
11278p -= l; len -= l; ret += l;
11279
11280e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
11281if (e) return e;
11282p -= l; len -= l; ret += l;
11283
11284ret += Top_tag_oldret;
11285}
11286/* pname */
11287if((data)->pname) {
11288size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11289ret = 0;
11290e = encode_PrincipalName(p, len, (data)->pname, &l);
11291if (e) return e;
11292p -= l; len -= l; ret += l;
11293
11294e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
11295if (e) return e;
11296p -= l; len -= l; ret += l;
11297
11298ret += Top_tag_oldret;
11299}
11300/* prealm */
11301if((data)->prealm) {
11302size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11303ret = 0;
11304e = encode_Realm(p, len, (data)->prealm, &l);
11305if (e) return e;
11306p -= l; len -= l; ret += l;
11307
11308e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
11309if (e) return e;
11310p -= l; len -= l; ret += l;
11311
11312ret += Top_tag_oldret;
11313}
11314/* key */
11315{
11316size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11317ret = 0;
11318e = encode_EncryptionKey(p, len, &(data)->key, &l);
11319if (e) return e;
11320p -= l; len -= l; ret += l;
11321
11322e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
11323if (e) return e;
11324p -= l; len -= l; ret += l;
11325
11326ret += Top_tag_oldret;
11327}
11328e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
11329if (e) return e;
11330p -= l; len -= l; ret += l;
11331
11332*size = ret;
11333return 0;
11334}
11335
11336int ASN1CALL
11337decode_KrbCredInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbCredInfo *data, size_t *size)
11338{
11339size_t ret = 0;
11340size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11341int e HEIMDAL_UNUSED_ATTRIBUTE;
11342
11343memset(data, 0, sizeof(*data));
11344{
11345size_t Top_datalen, Top_oldlen;
11346Der_type Top_type;
11347e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
11348if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
11349if(e) goto fail;
11350p += l; len -= l; ret += l;
11351Top_oldlen = len;
11352if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11353len = Top_datalen;
11354{
11355size_t key_datalen, key_oldlen;
11356Der_type key_type;
11357e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &key_type, 0, &key_datalen, &l);
11358if (e == 0 && key_type != CONS) { e = ASN1_BAD_ID; }
11359if(e) goto fail;
11360p += l; len -= l; ret += l;
11361key_oldlen = len;
11362if (key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11363len = key_datalen;
11364e = decode_EncryptionKey(p, len, &(data)->key, &l);
11365if(e) goto fail;
11366p += l; len -= l; ret += l;
11367len = key_oldlen - key_datalen;
11368}
11369{
11370size_t prealm_datalen, prealm_oldlen;
11371Der_type prealm_type;
11372e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &prealm_type, 1, &prealm_datalen, &l);
11373if (e == 0 && prealm_type != CONS) { e = ASN1_BAD_ID; }
11374if(e) {
11375(data)->prealm = NULL;
11376} else {
11377(data)->prealm = calloc(1, sizeof(*(data)->prealm));
11378if ((data)->prealm == NULL) { e = ENOMEM; goto fail; }
11379p += l; len -= l; ret += l;
11380prealm_oldlen = len;
11381if (prealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11382len = prealm_datalen;
11383e = decode_Realm(p, len, (data)->prealm, &l);
11384if(e) goto fail;
11385p += l; len -= l; ret += l;
11386len = prealm_oldlen - prealm_datalen;
11387}
11388}
11389{
11390size_t pname_datalen, pname_oldlen;
11391Der_type pname_type;
11392e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pname_type, 2, &pname_datalen, &l);
11393if (e == 0 && pname_type != CONS) { e = ASN1_BAD_ID; }
11394if(e) {
11395(data)->pname = NULL;
11396} else {
11397(data)->pname = calloc(1, sizeof(*(data)->pname));
11398if ((data)->pname == NULL) { e = ENOMEM; goto fail; }
11399p += l; len -= l; ret += l;
11400pname_oldlen = len;
11401if (pname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11402len = pname_datalen;
11403e = decode_PrincipalName(p, len, (data)->pname, &l);
11404if(e) goto fail;
11405p += l; len -= l; ret += l;
11406len = pname_oldlen - pname_datalen;
11407}
11408}
11409{
11410size_t flags_datalen, flags_oldlen;
11411Der_type flags_type;
11412e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 3, &flags_datalen, &l);
11413if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
11414if(e) {
11415(data)->flags = NULL;
11416} else {
11417(data)->flags = calloc(1, sizeof(*(data)->flags));
11418if ((data)->flags == NULL) { e = ENOMEM; goto fail; }
11419p += l; len -= l; ret += l;
11420flags_oldlen = len;
11421if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11422len = flags_datalen;
11423e = decode_TicketFlags(p, len, (data)->flags, &l);
11424if(e) goto fail;
11425p += l; len -= l; ret += l;
11426len = flags_oldlen - flags_datalen;
11427}
11428}
11429{
11430size_t authtime_datalen, authtime_oldlen;
11431Der_type authtime_type;
11432e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 4, &authtime_datalen, &l);
11433if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
11434if(e) {
11435(data)->authtime = NULL;
11436} else {
11437(data)->authtime = calloc(1, sizeof(*(data)->authtime));
11438if ((data)->authtime == NULL) { e = ENOMEM; goto fail; }
11439p += l; len -= l; ret += l;
11440authtime_oldlen = len;
11441if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11442len = authtime_datalen;
11443e = decode_KerberosTime(p, len, (data)->authtime, &l);
11444if(e) goto fail;
11445p += l; len -= l; ret += l;
11446len = authtime_oldlen - authtime_datalen;
11447}
11448}
11449{
11450size_t starttime_datalen, starttime_oldlen;
11451Der_type starttime_type;
11452e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 5, &starttime_datalen, &l);
11453if (e == 0 && starttime_type != CONS) { e = ASN1_BAD_ID; }
11454if(e) {
11455(data)->starttime = NULL;
11456} else {
11457(data)->starttime = calloc(1, sizeof(*(data)->starttime));
11458if ((data)->starttime == NULL) { e = ENOMEM; goto fail; }
11459p += l; len -= l; ret += l;
11460starttime_oldlen = len;
11461if (starttime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11462len = starttime_datalen;
11463e = decode_KerberosTime(p, len, (data)->starttime, &l);
11464if(e) goto fail;
11465p += l; len -= l; ret += l;
11466len = starttime_oldlen - starttime_datalen;
11467}
11468}
11469{
11470size_t endtime_datalen, endtime_oldlen;
11471Der_type endtime_type;
11472e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 6, &endtime_datalen, &l);
11473if (e == 0 && endtime_type != CONS) { e = ASN1_BAD_ID; }
11474if(e) {
11475(data)->endtime = NULL;
11476} else {
11477(data)->endtime = calloc(1, sizeof(*(data)->endtime));
11478if ((data)->endtime == NULL) { e = ENOMEM; goto fail; }
11479p += l; len -= l; ret += l;
11480endtime_oldlen = len;
11481if (endtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11482len = endtime_datalen;
11483e = decode_KerberosTime(p, len, (data)->endtime, &l);
11484if(e) goto fail;
11485p += l; len -= l; ret += l;
11486len = endtime_oldlen - endtime_datalen;
11487}
11488}
11489{
11490size_t renew_till_datalen, renew_till_oldlen;
11491Der_type renew_till_type;
11492e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 7, &renew_till_datalen, &l);
11493if (e == 0 && renew_till_type != CONS) { e = ASN1_BAD_ID; }
11494if(e) {
11495(data)->renew_till = NULL;
11496} else {
11497(data)->renew_till = calloc(1, sizeof(*(data)->renew_till));
11498if ((data)->renew_till == NULL) { e = ENOMEM; goto fail; }
11499p += l; len -= l; ret += l;
11500renew_till_oldlen = len;
11501if (renew_till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11502len = renew_till_datalen;
11503e = decode_KerberosTime(p, len, (data)->renew_till, &l);
11504if(e) goto fail;
11505p += l; len -= l; ret += l;
11506len = renew_till_oldlen - renew_till_datalen;
11507}
11508}
11509{
11510size_t srealm_datalen, srealm_oldlen;
11511Der_type srealm_type;
11512e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &srealm_type, 8, &srealm_datalen, &l);
11513if (e == 0 && srealm_type != CONS) { e = ASN1_BAD_ID; }
11514if(e) {
11515(data)->srealm = NULL;
11516} else {
11517(data)->srealm = calloc(1, sizeof(*(data)->srealm));
11518if ((data)->srealm == NULL) { e = ENOMEM; goto fail; }
11519p += l; len -= l; ret += l;
11520srealm_oldlen = len;
11521if (srealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11522len = srealm_datalen;
11523e = decode_Realm(p, len, (data)->srealm, &l);
11524if(e) goto fail;
11525p += l; len -= l; ret += l;
11526len = srealm_oldlen - srealm_datalen;
11527}
11528}
11529{
11530size_t sname_datalen, sname_oldlen;
11531Der_type sname_type;
11532e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 9, &sname_datalen, &l);
11533if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
11534if(e) {
11535(data)->sname = NULL;
11536} else {
11537(data)->sname = calloc(1, sizeof(*(data)->sname));
11538if ((data)->sname == NULL) { e = ENOMEM; goto fail; }
11539p += l; len -= l; ret += l;
11540sname_oldlen = len;
11541if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11542len = sname_datalen;
11543e = decode_PrincipalName(p, len, (data)->sname, &l);
11544if(e) goto fail;
11545p += l; len -= l; ret += l;
11546len = sname_oldlen - sname_datalen;
11547}
11548}
11549{
11550size_t caddr_datalen, caddr_oldlen;
11551Der_type caddr_type;
11552e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &caddr_type, 10, &caddr_datalen, &l);
11553if (e == 0 && caddr_type != CONS) { e = ASN1_BAD_ID; }
11554if(e) {
11555(data)->caddr = NULL;
11556} else {
11557(data)->caddr = calloc(1, sizeof(*(data)->caddr));
11558if ((data)->caddr == NULL) { e = ENOMEM; goto fail; }
11559p += l; len -= l; ret += l;
11560caddr_oldlen = len;
11561if (caddr_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11562len = caddr_datalen;
11563e = decode_HostAddresses(p, len, (data)->caddr, &l);
11564if(e) goto fail;
11565p += l; len -= l; ret += l;
11566len = caddr_oldlen - caddr_datalen;
11567}
11568}
11569len = Top_oldlen - Top_datalen;
11570}
11571if(size) *size = ret;
11572return 0;
11573fail:
11574free_KrbCredInfo(data);
11575return e;
11576}
11577
11578void ASN1CALL
11579free_KrbCredInfo(KrbCredInfo *data)
11580{
11581free_EncryptionKey(&(data)->key);
11582if((data)->prealm) {
11583free_Realm((data)->prealm);
11584free((data)->prealm);
11585(data)->prealm = NULL;
11586}
11587if((data)->pname) {
11588free_PrincipalName((data)->pname);
11589free((data)->pname);
11590(data)->pname = NULL;
11591}
11592if((data)->flags) {
11593free_TicketFlags((data)->flags);
11594free((data)->flags);
11595(data)->flags = NULL;
11596}
11597if((data)->authtime) {
11598free_KerberosTime((data)->authtime);
11599free((data)->authtime);
11600(data)->authtime = NULL;
11601}
11602if((data)->starttime) {
11603free_KerberosTime((data)->starttime);
11604free((data)->starttime);
11605(data)->starttime = NULL;
11606}
11607if((data)->endtime) {
11608free_KerberosTime((data)->endtime);
11609free((data)->endtime);
11610(data)->endtime = NULL;
11611}
11612if((data)->renew_till) {
11613free_KerberosTime((data)->renew_till);
11614free((data)->renew_till);
11615(data)->renew_till = NULL;
11616}
11617if((data)->srealm) {
11618free_Realm((data)->srealm);
11619free((data)->srealm);
11620(data)->srealm = NULL;
11621}
11622if((data)->sname) {
11623free_PrincipalName((data)->sname);
11624free((data)->sname);
11625(data)->sname = NULL;
11626}
11627if((data)->caddr) {
11628free_HostAddresses((data)->caddr);
11629free((data)->caddr);
11630(data)->caddr = NULL;
11631}
11632}
11633
11634size_t ASN1CALL
11635length_KrbCredInfo(const KrbCredInfo *data)
11636{
11637size_t ret = 0;
11638{
11639size_t Top_tag_oldret = ret;
11640ret = 0;
11641ret += length_EncryptionKey(&(data)->key);
11642ret += 1 + der_length_len (ret);
11643ret += Top_tag_oldret;
11644}
11645if((data)->prealm){
11646size_t Top_tag_oldret = ret;
11647ret = 0;
11648ret += length_Realm((data)->prealm);
11649ret += 1 + der_length_len (ret);
11650ret += Top_tag_oldret;
11651}
11652if((data)->pname){
11653size_t Top_tag_oldret = ret;
11654ret = 0;
11655ret += length_PrincipalName((data)->pname);
11656ret += 1 + der_length_len (ret);
11657ret += Top_tag_oldret;
11658}
11659if((data)->flags){
11660size_t Top_tag_oldret = ret;
11661ret = 0;
11662ret += length_TicketFlags((data)->flags);
11663ret += 1 + der_length_len (ret);
11664ret += Top_tag_oldret;
11665}
11666if((data)->authtime){
11667size_t Top_tag_oldret = ret;
11668ret = 0;
11669ret += length_KerberosTime((data)->authtime);
11670ret += 1 + der_length_len (ret);
11671ret += Top_tag_oldret;
11672}
11673if((data)->starttime){
11674size_t Top_tag_oldret = ret;
11675ret = 0;
11676ret += length_KerberosTime((data)->starttime);
11677ret += 1 + der_length_len (ret);
11678ret += Top_tag_oldret;
11679}
11680if((data)->endtime){
11681size_t Top_tag_oldret = ret;
11682ret = 0;
11683ret += length_KerberosTime((data)->endtime);
11684ret += 1 + der_length_len (ret);
11685ret += Top_tag_oldret;
11686}
11687if((data)->renew_till){
11688size_t Top_tag_oldret = ret;
11689ret = 0;
11690ret += length_KerberosTime((data)->renew_till);
11691ret += 1 + der_length_len (ret);
11692ret += Top_tag_oldret;
11693}
11694if((data)->srealm){
11695size_t Top_tag_oldret = ret;
11696ret = 0;
11697ret += length_Realm((data)->srealm);
11698ret += 1 + der_length_len (ret);
11699ret += Top_tag_oldret;
11700}
11701if((data)->sname){
11702size_t Top_tag_oldret = ret;
11703ret = 0;
11704ret += length_PrincipalName((data)->sname);
11705ret += 1 + der_length_len (ret);
11706ret += Top_tag_oldret;
11707}
11708if((data)->caddr){
11709size_t Top_tag_oldret = ret;
11710ret = 0;
11711ret += length_HostAddresses((data)->caddr);
11712ret += 1 + der_length_len (ret);
11713ret += Top_tag_oldret;
11714}
11715ret += 1 + der_length_len (ret);
11716return ret;
11717}
11718
11719int ASN1CALL
11720copy_KrbCredInfo(const KrbCredInfo *from, KrbCredInfo *to)
11721{
11722memset(to, 0, sizeof(*to));
11723if(copy_EncryptionKey(&(from)->key, &(to)->key)) goto fail;
11724if((from)->prealm) {
11725(to)->prealm = malloc(sizeof(*(to)->prealm));
11726if((to)->prealm == NULL) goto fail;
11727if(copy_Realm((from)->prealm, (to)->prealm)) goto fail;
11728}else
11729(to)->prealm = NULL;
11730if((from)->pname) {
11731(to)->pname = malloc(sizeof(*(to)->pname));
11732if((to)->pname == NULL) goto fail;
11733if(copy_PrincipalName((from)->pname, (to)->pname)) goto fail;
11734}else
11735(to)->pname = NULL;
11736if((from)->flags) {
11737(to)->flags = malloc(sizeof(*(to)->flags));
11738if((to)->flags == NULL) goto fail;
11739if(copy_TicketFlags((from)->flags, (to)->flags)) goto fail;
11740}else
11741(to)->flags = NULL;
11742if((from)->authtime) {
11743(to)->authtime = malloc(sizeof(*(to)->authtime));
11744if((to)->authtime == NULL) goto fail;
11745if(copy_KerberosTime((from)->authtime, (to)->authtime)) goto fail;
11746}else
11747(to)->authtime = NULL;
11748if((from)->starttime) {
11749(to)->starttime = malloc(sizeof(*(to)->starttime));
11750if((to)->starttime == NULL) goto fail;
11751if(copy_KerberosTime((from)->starttime, (to)->starttime)) goto fail;
11752}else
11753(to)->starttime = NULL;
11754if((from)->endtime) {
11755(to)->endtime = malloc(sizeof(*(to)->endtime));
11756if((to)->endtime == NULL) goto fail;
11757if(copy_KerberosTime((from)->endtime, (to)->endtime)) goto fail;
11758}else
11759(to)->endtime = NULL;
11760if((from)->renew_till) {
11761(to)->renew_till = malloc(sizeof(*(to)->renew_till));
11762if((to)->renew_till == NULL) goto fail;
11763if(copy_KerberosTime((from)->renew_till, (to)->renew_till)) goto fail;
11764}else
11765(to)->renew_till = NULL;
11766if((from)->srealm) {
11767(to)->srealm = malloc(sizeof(*(to)->srealm));
11768if((to)->srealm == NULL) goto fail;
11769if(copy_Realm((from)->srealm, (to)->srealm)) goto fail;
11770}else
11771(to)->srealm = NULL;
11772if((from)->sname) {
11773(to)->sname = malloc(sizeof(*(to)->sname));
11774if((to)->sname == NULL) goto fail;
11775if(copy_PrincipalName((from)->sname, (to)->sname)) goto fail;
11776}else
11777(to)->sname = NULL;
11778if((from)->caddr) {
11779(to)->caddr = malloc(sizeof(*(to)->caddr));
11780if((to)->caddr == NULL) goto fail;
11781if(copy_HostAddresses((from)->caddr, (to)->caddr)) goto fail;
11782}else
11783(to)->caddr = NULL;
11784return 0;
11785fail:
11786free_KrbCredInfo(to);
11787return ENOMEM;
11788}
11789
11790int ASN1CALL
11791encode_EncKrbCredPart(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncKrbCredPart *data, size_t *size)
11792{
11793size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
11794size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11795int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
11796
11797/* r-address */
11798if((data)->r_address) {
11799size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11800ret = 0;
11801e = encode_HostAddress(p, len, (data)->r_address, &l);
11802if (e) return e;
11803p -= l; len -= l; ret += l;
11804
11805e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
11806if (e) return e;
11807p -= l; len -= l; ret += l;
11808
11809ret += Top_tag_tag_oldret;
11810}
11811/* s-address */
11812if((data)->s_address) {
11813size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11814ret = 0;
11815e = encode_HostAddress(p, len, (data)->s_address, &l);
11816if (e) return e;
11817p -= l; len -= l; ret += l;
11818
11819e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
11820if (e) return e;
11821p -= l; len -= l; ret += l;
11822
11823ret += Top_tag_tag_oldret;
11824}
11825/* usec */
11826if((data)->usec) {
11827size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11828ret = 0;
11829e = encode_krb5int32(p, len, (data)->usec, &l);
11830if (e) return e;
11831p -= l; len -= l; ret += l;
11832
11833e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
11834if (e) return e;
11835p -= l; len -= l; ret += l;
11836
11837ret += Top_tag_tag_oldret;
11838}
11839/* timestamp */
11840if((data)->timestamp) {
11841size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11842ret = 0;
11843e = encode_KerberosTime(p, len, (data)->timestamp, &l);
11844if (e) return e;
11845p -= l; len -= l; ret += l;
11846
11847e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
11848if (e) return e;
11849p -= l; len -= l; ret += l;
11850
11851ret += Top_tag_tag_oldret;
11852}
11853/* nonce */
11854if((data)->nonce) {
11855size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11856ret = 0;
11857e = encode_krb5int32(p, len, (data)->nonce, &l);
11858if (e) return e;
11859p -= l; len -= l; ret += l;
11860
11861e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
11862if (e) return e;
11863p -= l; len -= l; ret += l;
11864
11865ret += Top_tag_tag_oldret;
11866}
11867/* ticket-info */
11868{
11869size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
11870ret = 0;
11871for(i = (int)(&(data)->ticket_info)->len - 1; i >= 0; --i) {
11872size_t ticket_info_tag_tag_for_oldret = ret;
11873ret = 0;
11874e = encode_KrbCredInfo(p, len, &(&(data)->ticket_info)->val[i], &l);
11875if (e) return e;
11876p -= l; len -= l; ret += l;
11877
11878ret += ticket_info_tag_tag_for_oldret;
11879}
11880e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
11881if (e) return e;
11882p -= l; len -= l; ret += l;
11883
11884e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
11885if (e) return e;
11886p -= l; len -= l; ret += l;
11887
11888ret += Top_tag_tag_oldret;
11889}
11890e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
11891if (e) return e;
11892p -= l; len -= l; ret += l;
11893
11894e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 29, &l);
11895if (e) return e;
11896p -= l; len -= l; ret += l;
11897
11898*size = ret;
11899return 0;
11900}
11901
11902int ASN1CALL
11903decode_EncKrbCredPart(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncKrbCredPart *data, size_t *size)
11904{
11905size_t ret = 0;
11906size_t l HEIMDAL_UNUSED_ATTRIBUTE;
11907int e HEIMDAL_UNUSED_ATTRIBUTE;
11908
11909memset(data, 0, sizeof(*data));
11910{
11911size_t Top_datalen, Top_oldlen;
11912Der_type Top_type;
11913e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 29, &Top_datalen, &l);
11914if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
11915if(e) goto fail;
11916p += l; len -= l; ret += l;
11917Top_oldlen = len;
11918if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11919len = Top_datalen;
11920{
11921size_t Top_Tag_datalen, Top_Tag_oldlen;
11922Der_type Top_Tag_type;
11923e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
11924if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
11925if(e) goto fail;
11926p += l; len -= l; ret += l;
11927Top_Tag_oldlen = len;
11928if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11929len = Top_Tag_datalen;
11930{
11931size_t ticket_info_datalen, ticket_info_oldlen;
11932Der_type ticket_info_type;
11933e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_info_type, 0, &ticket_info_datalen, &l);
11934if (e == 0 && ticket_info_type != CONS) { e = ASN1_BAD_ID; }
11935if(e) goto fail;
11936p += l; len -= l; ret += l;
11937ticket_info_oldlen = len;
11938if (ticket_info_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11939len = ticket_info_datalen;
11940{
11941size_t ticket_info_Tag_datalen, ticket_info_Tag_oldlen;
11942Der_type ticket_info_Tag_type;
11943e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ticket_info_Tag_type, UT_Sequence, &ticket_info_Tag_datalen, &l);
11944if (e == 0 && ticket_info_Tag_type != CONS) { e = ASN1_BAD_ID; }
11945if(e) goto fail;
11946p += l; len -= l; ret += l;
11947ticket_info_Tag_oldlen = len;
11948if (ticket_info_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11949len = ticket_info_Tag_datalen;
11950{
11951size_t ticket_info_Tag_Tag_origlen = len;
11952size_t ticket_info_Tag_Tag_oldret = ret;
11953size_t ticket_info_Tag_Tag_olen = 0;
11954void *ticket_info_Tag_Tag_tmp;
11955ret = 0;
11956(&(data)->ticket_info)->len = 0;
11957(&(data)->ticket_info)->val = NULL;
11958while(ret < ticket_info_Tag_Tag_origlen) {
11959size_t ticket_info_Tag_Tag_nlen = ticket_info_Tag_Tag_olen + sizeof(*((&(data)->ticket_info)->val));
11960if (ticket_info_Tag_Tag_olen > ticket_info_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
11961ticket_info_Tag_Tag_olen = ticket_info_Tag_Tag_nlen;
11962ticket_info_Tag_Tag_tmp = realloc((&(data)->ticket_info)->val, ticket_info_Tag_Tag_olen);
11963if (ticket_info_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
11964(&(data)->ticket_info)->val = ticket_info_Tag_Tag_tmp;
11965e = decode_KrbCredInfo(p, len, &(&(data)->ticket_info)->val[(&(data)->ticket_info)->len], &l);
11966if(e) goto fail;
11967p += l; len -= l; ret += l;
11968(&(data)->ticket_info)->len++;
11969len = ticket_info_Tag_Tag_origlen - ret;
11970}
11971ret += ticket_info_Tag_Tag_oldret;
11972}
11973len = ticket_info_Tag_oldlen - ticket_info_Tag_datalen;
11974}
11975len = ticket_info_oldlen - ticket_info_datalen;
11976}
11977{
11978size_t nonce_datalen, nonce_oldlen;
11979Der_type nonce_type;
11980e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonce_type, 1, &nonce_datalen, &l);
11981if (e == 0 && nonce_type != CONS) { e = ASN1_BAD_ID; }
11982if(e) {
11983(data)->nonce = NULL;
11984} else {
11985(data)->nonce = calloc(1, sizeof(*(data)->nonce));
11986if ((data)->nonce == NULL) { e = ENOMEM; goto fail; }
11987p += l; len -= l; ret += l;
11988nonce_oldlen = len;
11989if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
11990len = nonce_datalen;
11991e = decode_krb5int32(p, len, (data)->nonce, &l);
11992if(e) goto fail;
11993p += l; len -= l; ret += l;
11994len = nonce_oldlen - nonce_datalen;
11995}
11996}
11997{
11998size_t timestamp_datalen, timestamp_oldlen;
11999Der_type timestamp_type;
12000e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &timestamp_type, 2, &timestamp_datalen, &l);
12001if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
12002if(e) {
12003(data)->timestamp = NULL;
12004} else {
12005(data)->timestamp = calloc(1, sizeof(*(data)->timestamp));
12006if ((data)->timestamp == NULL) { e = ENOMEM; goto fail; }
12007p += l; len -= l; ret += l;
12008timestamp_oldlen = len;
12009if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12010len = timestamp_datalen;
12011e = decode_KerberosTime(p, len, (data)->timestamp, &l);
12012if(e) goto fail;
12013p += l; len -= l; ret += l;
12014len = timestamp_oldlen - timestamp_datalen;
12015}
12016}
12017{
12018size_t usec_datalen, usec_oldlen;
12019Der_type usec_type;
12020e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 3, &usec_datalen, &l);
12021if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
12022if(e) {
12023(data)->usec = NULL;
12024} else {
12025(data)->usec = calloc(1, sizeof(*(data)->usec));
12026if ((data)->usec == NULL) { e = ENOMEM; goto fail; }
12027p += l; len -= l; ret += l;
12028usec_oldlen = len;
12029if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12030len = usec_datalen;
12031e = decode_krb5int32(p, len, (data)->usec, &l);
12032if(e) goto fail;
12033p += l; len -= l; ret += l;
12034len = usec_oldlen - usec_datalen;
12035}
12036}
12037{
12038size_t s_address_datalen, s_address_oldlen;
12039Der_type s_address_type;
12040e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &s_address_type, 4, &s_address_datalen, &l);
12041if (e == 0 && s_address_type != CONS) { e = ASN1_BAD_ID; }
12042if(e) {
12043(data)->s_address = NULL;
12044} else {
12045(data)->s_address = calloc(1, sizeof(*(data)->s_address));
12046if ((data)->s_address == NULL) { e = ENOMEM; goto fail; }
12047p += l; len -= l; ret += l;
12048s_address_oldlen = len;
12049if (s_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12050len = s_address_datalen;
12051e = decode_HostAddress(p, len, (data)->s_address, &l);
12052if(e) goto fail;
12053p += l; len -= l; ret += l;
12054len = s_address_oldlen - s_address_datalen;
12055}
12056}
12057{
12058size_t r_address_datalen, r_address_oldlen;
12059Der_type r_address_type;
12060e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &r_address_type, 5, &r_address_datalen, &l);
12061if (e == 0 && r_address_type != CONS) { e = ASN1_BAD_ID; }
12062if(e) {
12063(data)->r_address = NULL;
12064} else {
12065(data)->r_address = calloc(1, sizeof(*(data)->r_address));
12066if ((data)->r_address == NULL) { e = ENOMEM; goto fail; }
12067p += l; len -= l; ret += l;
12068r_address_oldlen = len;
12069if (r_address_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12070len = r_address_datalen;
12071e = decode_HostAddress(p, len, (data)->r_address, &l);
12072if(e) goto fail;
12073p += l; len -= l; ret += l;
12074len = r_address_oldlen - r_address_datalen;
12075}
12076}
12077len = Top_Tag_oldlen - Top_Tag_datalen;
12078}
12079len = Top_oldlen - Top_datalen;
12080}
12081if(size) *size = ret;
12082return 0;
12083fail:
12084free_EncKrbCredPart(data);
12085return e;
12086}
12087
12088void ASN1CALL
12089free_EncKrbCredPart(EncKrbCredPart *data)
12090{
12091while((&(data)->ticket_info)->len){
12092free_KrbCredInfo(&(&(data)->ticket_info)->val[(&(data)->ticket_info)->len-1]);
12093(&(data)->ticket_info)->len--;
12094}
12095free((&(data)->ticket_info)->val);
12096(&(data)->ticket_info)->val = NULL;
12097if((data)->nonce) {
12098free_krb5int32((data)->nonce);
12099free((data)->nonce);
12100(data)->nonce = NULL;
12101}
12102if((data)->timestamp) {
12103free_KerberosTime((data)->timestamp);
12104free((data)->timestamp);
12105(data)->timestamp = NULL;
12106}
12107if((data)->usec) {
12108free_krb5int32((data)->usec);
12109free((data)->usec);
12110(data)->usec = NULL;
12111}
12112if((data)->s_address) {
12113free_HostAddress((data)->s_address);
12114free((data)->s_address);
12115(data)->s_address = NULL;
12116}
12117if((data)->r_address) {
12118free_HostAddress((data)->r_address);
12119free((data)->r_address);
12120(data)->r_address = NULL;
12121}
12122}
12123
12124size_t ASN1CALL
12125length_EncKrbCredPart(const EncKrbCredPart *data)
12126{
12127size_t ret = 0;
12128{
12129size_t Top_tag_tag_oldret = ret;
12130ret = 0;
12131{
12132size_t ticket_info_tag_tag_oldret = ret;
12133unsigned int n_ticket_info_tag_tag;
12134ret = 0;
12135for(n_ticket_info_tag_tag = (&(data)->ticket_info)->len; n_ticket_info_tag_tag > 0; --n_ticket_info_tag_tag){
12136size_t ticket_info_tag_tag_for_oldret = ret;
12137ret = 0;
12138ret += length_KrbCredInfo(&(&(data)->ticket_info)->val[n_ticket_info_tag_tag - 1]);
12139ret += ticket_info_tag_tag_for_oldret;
12140}
12141ret += ticket_info_tag_tag_oldret;
12142}
12143ret += 1 + der_length_len (ret);
12144ret += 1 + der_length_len (ret);
12145ret += Top_tag_tag_oldret;
12146}
12147if((data)->nonce){
12148size_t Top_tag_tag_oldret = ret;
12149ret = 0;
12150ret += length_krb5int32((data)->nonce);
12151ret += 1 + der_length_len (ret);
12152ret += Top_tag_tag_oldret;
12153}
12154if((data)->timestamp){
12155size_t Top_tag_tag_oldret = ret;
12156ret = 0;
12157ret += length_KerberosTime((data)->timestamp);
12158ret += 1 + der_length_len (ret);
12159ret += Top_tag_tag_oldret;
12160}
12161if((data)->usec){
12162size_t Top_tag_tag_oldret = ret;
12163ret = 0;
12164ret += length_krb5int32((data)->usec);
12165ret += 1 + der_length_len (ret);
12166ret += Top_tag_tag_oldret;
12167}
12168if((data)->s_address){
12169size_t Top_tag_tag_oldret = ret;
12170ret = 0;
12171ret += length_HostAddress((data)->s_address);
12172ret += 1 + der_length_len (ret);
12173ret += Top_tag_tag_oldret;
12174}
12175if((data)->r_address){
12176size_t Top_tag_tag_oldret = ret;
12177ret = 0;
12178ret += length_HostAddress((data)->r_address);
12179ret += 1 + der_length_len (ret);
12180ret += Top_tag_tag_oldret;
12181}
12182ret += 1 + der_length_len (ret);
12183ret += 1 + der_length_len (ret);
12184return ret;
12185}
12186
12187int ASN1CALL
12188copy_EncKrbCredPart(const EncKrbCredPart *from, EncKrbCredPart *to)
12189{
12190memset(to, 0, sizeof(*to));
12191if(((&(to)->ticket_info)->val = malloc((&(from)->ticket_info)->len * sizeof(*(&(to)->ticket_info)->val))) == NULL && (&(from)->ticket_info)->len != 0)
12192goto fail;
12193for((&(to)->ticket_info)->len = 0; (&(to)->ticket_info)->len < (&(from)->ticket_info)->len; (&(to)->ticket_info)->len++){
12194if(copy_KrbCredInfo(&(&(from)->ticket_info)->val[(&(to)->ticket_info)->len], &(&(to)->ticket_info)->val[(&(to)->ticket_info)->len])) goto fail;
12195}
12196if((from)->nonce) {
12197(to)->nonce = malloc(sizeof(*(to)->nonce));
12198if((to)->nonce == NULL) goto fail;
12199if(copy_krb5int32((from)->nonce, (to)->nonce)) goto fail;
12200}else
12201(to)->nonce = NULL;
12202if((from)->timestamp) {
12203(to)->timestamp = malloc(sizeof(*(to)->timestamp));
12204if((to)->timestamp == NULL) goto fail;
12205if(copy_KerberosTime((from)->timestamp, (to)->timestamp)) goto fail;
12206}else
12207(to)->timestamp = NULL;
12208if((from)->usec) {
12209(to)->usec = malloc(sizeof(*(to)->usec));
12210if((to)->usec == NULL) goto fail;
12211if(copy_krb5int32((from)->usec, (to)->usec)) goto fail;
12212}else
12213(to)->usec = NULL;
12214if((from)->s_address) {
12215(to)->s_address = malloc(sizeof(*(to)->s_address));
12216if((to)->s_address == NULL) goto fail;
12217if(copy_HostAddress((from)->s_address, (to)->s_address)) goto fail;
12218}else
12219(to)->s_address = NULL;
12220if((from)->r_address) {
12221(to)->r_address = malloc(sizeof(*(to)->r_address));
12222if((to)->r_address == NULL) goto fail;
12223if(copy_HostAddress((from)->r_address, (to)->r_address)) goto fail;
12224}else
12225(to)->r_address = NULL;
12226return 0;
12227fail:
12228free_EncKrbCredPart(to);
12229return ENOMEM;
12230}
12231
12232int ASN1CALL
12233encode_KRB_ERROR(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB_ERROR *data, size_t *size)
12234{
12235size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
12236size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12237int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
12238
12239/* e-data */
12240if((data)->e_data) {
12241size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12242ret = 0;
12243e = der_put_octet_string(p, len, (data)->e_data, &l);
12244if (e) return e;
12245p -= l; len -= l; ret += l;
12246
12247e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
12248if (e) return e;
12249p -= l; len -= l; ret += l;
12250
12251e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 12, &l);
12252if (e) return e;
12253p -= l; len -= l; ret += l;
12254
12255ret += Top_tag_tag_oldret;
12256}
12257/* e-text */
12258if((data)->e_text) {
12259size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12260ret = 0;
12261e = der_put_general_string(p, len, (data)->e_text, &l);
12262if (e) return e;
12263p -= l; len -= l; ret += l;
12264
12265e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
12266if (e) return e;
12267p -= l; len -= l; ret += l;
12268
12269e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 11, &l);
12270if (e) return e;
12271p -= l; len -= l; ret += l;
12272
12273ret += Top_tag_tag_oldret;
12274}
12275/* sname */
12276{
12277size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12278ret = 0;
12279e = encode_PrincipalName(p, len, &(data)->sname, &l);
12280if (e) return e;
12281p -= l; len -= l; ret += l;
12282
12283e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
12284if (e) return e;
12285p -= l; len -= l; ret += l;
12286
12287ret += Top_tag_tag_oldret;
12288}
12289/* realm */
12290{
12291size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12292ret = 0;
12293e = encode_Realm(p, len, &(data)->realm, &l);
12294if (e) return e;
12295p -= l; len -= l; ret += l;
12296
12297e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
12298if (e) return e;
12299p -= l; len -= l; ret += l;
12300
12301ret += Top_tag_tag_oldret;
12302}
12303/* cname */
12304if((data)->cname) {
12305size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12306ret = 0;
12307e = encode_PrincipalName(p, len, (data)->cname, &l);
12308if (e) return e;
12309p -= l; len -= l; ret += l;
12310
12311e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
12312if (e) return e;
12313p -= l; len -= l; ret += l;
12314
12315ret += Top_tag_tag_oldret;
12316}
12317/* crealm */
12318if((data)->crealm) {
12319size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12320ret = 0;
12321e = encode_Realm(p, len, (data)->crealm, &l);
12322if (e) return e;
12323p -= l; len -= l; ret += l;
12324
12325e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
12326if (e) return e;
12327p -= l; len -= l; ret += l;
12328
12329ret += Top_tag_tag_oldret;
12330}
12331/* error-code */
12332{
12333size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12334ret = 0;
12335e = encode_krb5int32(p, len, &(data)->error_code, &l);
12336if (e) return e;
12337p -= l; len -= l; ret += l;
12338
12339e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
12340if (e) return e;
12341p -= l; len -= l; ret += l;
12342
12343ret += Top_tag_tag_oldret;
12344}
12345/* susec */
12346{
12347size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12348ret = 0;
12349e = encode_krb5int32(p, len, &(data)->susec, &l);
12350if (e) return e;
12351p -= l; len -= l; ret += l;
12352
12353e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
12354if (e) return e;
12355p -= l; len -= l; ret += l;
12356
12357ret += Top_tag_tag_oldret;
12358}
12359/* stime */
12360{
12361size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12362ret = 0;
12363e = encode_KerberosTime(p, len, &(data)->stime, &l);
12364if (e) return e;
12365p -= l; len -= l; ret += l;
12366
12367e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
12368if (e) return e;
12369p -= l; len -= l; ret += l;
12370
12371ret += Top_tag_tag_oldret;
12372}
12373/* cusec */
12374if((data)->cusec) {
12375size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12376ret = 0;
12377e = encode_krb5int32(p, len, (data)->cusec, &l);
12378if (e) return e;
12379p -= l; len -= l; ret += l;
12380
12381e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
12382if (e) return e;
12383p -= l; len -= l; ret += l;
12384
12385ret += Top_tag_tag_oldret;
12386}
12387/* ctime */
12388if((data)->ctime) {
12389size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12390ret = 0;
12391e = encode_KerberosTime(p, len, (data)->ctime, &l);
12392if (e) return e;
12393p -= l; len -= l; ret += l;
12394
12395e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
12396if (e) return e;
12397p -= l; len -= l; ret += l;
12398
12399ret += Top_tag_tag_oldret;
12400}
12401/* msg-type */
12402{
12403size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12404ret = 0;
12405e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
12406if (e) return e;
12407p -= l; len -= l; ret += l;
12408
12409e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
12410if (e) return e;
12411p -= l; len -= l; ret += l;
12412
12413ret += Top_tag_tag_oldret;
12414}
12415/* pvno */
12416{
12417size_t Top_tag_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12418ret = 0;
12419e = encode_krb5int32(p, len, &(data)->pvno, &l);
12420if (e) return e;
12421p -= l; len -= l; ret += l;
12422
12423e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
12424if (e) return e;
12425p -= l; len -= l; ret += l;
12426
12427ret += Top_tag_tag_oldret;
12428}
12429e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
12430if (e) return e;
12431p -= l; len -= l; ret += l;
12432
12433e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 30, &l);
12434if (e) return e;
12435p -= l; len -= l; ret += l;
12436
12437*size = ret;
12438return 0;
12439}
12440
12441int ASN1CALL
12442decode_KRB_ERROR(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB_ERROR *data, size_t *size)
12443{
12444size_t ret = 0;
12445size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12446int e HEIMDAL_UNUSED_ATTRIBUTE;
12447
12448memset(data, 0, sizeof(*data));
12449{
12450size_t Top_datalen, Top_oldlen;
12451Der_type Top_type;
12452e = der_match_tag_and_length(p, len, ASN1_C_APPL, &Top_type, 30, &Top_datalen, &l);
12453if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
12454if(e) goto fail;
12455p += l; len -= l; ret += l;
12456Top_oldlen = len;
12457if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12458len = Top_datalen;
12459{
12460size_t Top_Tag_datalen, Top_Tag_oldlen;
12461Der_type Top_Tag_type;
12462e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_type, UT_Sequence, &Top_Tag_datalen, &l);
12463if (e == 0 && Top_Tag_type != CONS) { e = ASN1_BAD_ID; }
12464if(e) goto fail;
12465p += l; len -= l; ret += l;
12466Top_Tag_oldlen = len;
12467if (Top_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12468len = Top_Tag_datalen;
12469{
12470size_t pvno_datalen, pvno_oldlen;
12471Der_type pvno_type;
12472e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &pvno_type, 0, &pvno_datalen, &l);
12473if (e == 0 && pvno_type != CONS) { e = ASN1_BAD_ID; }
12474if(e) goto fail;
12475p += l; len -= l; ret += l;
12476pvno_oldlen = len;
12477if (pvno_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12478len = pvno_datalen;
12479e = decode_krb5int32(p, len, &(data)->pvno, &l);
12480if(e) goto fail;
12481p += l; len -= l; ret += l;
12482len = pvno_oldlen - pvno_datalen;
12483}
12484{
12485size_t msg_type_datalen, msg_type_oldlen;
12486Der_type msg_type_type;
12487e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &msg_type_type, 1, &msg_type_datalen, &l);
12488if (e == 0 && msg_type_type != CONS) { e = ASN1_BAD_ID; }
12489if(e) goto fail;
12490p += l; len -= l; ret += l;
12491msg_type_oldlen = len;
12492if (msg_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12493len = msg_type_datalen;
12494e = decode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
12495if(e) goto fail;
12496p += l; len -= l; ret += l;
12497len = msg_type_oldlen - msg_type_datalen;
12498}
12499{
12500size_t ctime_datalen, ctime_oldlen;
12501Der_type ctime_type;
12502e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ctime_type, 2, &ctime_datalen, &l);
12503if (e == 0 && ctime_type != CONS) { e = ASN1_BAD_ID; }
12504if(e) {
12505(data)->ctime = NULL;
12506} else {
12507(data)->ctime = calloc(1, sizeof(*(data)->ctime));
12508if ((data)->ctime == NULL) { e = ENOMEM; goto fail; }
12509p += l; len -= l; ret += l;
12510ctime_oldlen = len;
12511if (ctime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12512len = ctime_datalen;
12513e = decode_KerberosTime(p, len, (data)->ctime, &l);
12514if(e) goto fail;
12515p += l; len -= l; ret += l;
12516len = ctime_oldlen - ctime_datalen;
12517}
12518}
12519{
12520size_t cusec_datalen, cusec_oldlen;
12521Der_type cusec_type;
12522e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cusec_type, 3, &cusec_datalen, &l);
12523if (e == 0 && cusec_type != CONS) { e = ASN1_BAD_ID; }
12524if(e) {
12525(data)->cusec = NULL;
12526} else {
12527(data)->cusec = calloc(1, sizeof(*(data)->cusec));
12528if ((data)->cusec == NULL) { e = ENOMEM; goto fail; }
12529p += l; len -= l; ret += l;
12530cusec_oldlen = len;
12531if (cusec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12532len = cusec_datalen;
12533e = decode_krb5int32(p, len, (data)->cusec, &l);
12534if(e) goto fail;
12535p += l; len -= l; ret += l;
12536len = cusec_oldlen - cusec_datalen;
12537}
12538}
12539{
12540size_t stime_datalen, stime_oldlen;
12541Der_type stime_type;
12542e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &stime_type, 4, &stime_datalen, &l);
12543if (e == 0 && stime_type != CONS) { e = ASN1_BAD_ID; }
12544if(e) goto fail;
12545p += l; len -= l; ret += l;
12546stime_oldlen = len;
12547if (stime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12548len = stime_datalen;
12549e = decode_KerberosTime(p, len, &(data)->stime, &l);
12550if(e) goto fail;
12551p += l; len -= l; ret += l;
12552len = stime_oldlen - stime_datalen;
12553}
12554{
12555size_t susec_datalen, susec_oldlen;
12556Der_type susec_type;
12557e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &susec_type, 5, &susec_datalen, &l);
12558if (e == 0 && susec_type != CONS) { e = ASN1_BAD_ID; }
12559if(e) goto fail;
12560p += l; len -= l; ret += l;
12561susec_oldlen = len;
12562if (susec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12563len = susec_datalen;
12564e = decode_krb5int32(p, len, &(data)->susec, &l);
12565if(e) goto fail;
12566p += l; len -= l; ret += l;
12567len = susec_oldlen - susec_datalen;
12568}
12569{
12570size_t error_code_datalen, error_code_oldlen;
12571Der_type error_code_type;
12572e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &error_code_type, 6, &error_code_datalen, &l);
12573if (e == 0 && error_code_type != CONS) { e = ASN1_BAD_ID; }
12574if(e) goto fail;
12575p += l; len -= l; ret += l;
12576error_code_oldlen = len;
12577if (error_code_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12578len = error_code_datalen;
12579e = decode_krb5int32(p, len, &(data)->error_code, &l);
12580if(e) goto fail;
12581p += l; len -= l; ret += l;
12582len = error_code_oldlen - error_code_datalen;
12583}
12584{
12585size_t crealm_datalen, crealm_oldlen;
12586Der_type crealm_type;
12587e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 7, &crealm_datalen, &l);
12588if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
12589if(e) {
12590(data)->crealm = NULL;
12591} else {
12592(data)->crealm = calloc(1, sizeof(*(data)->crealm));
12593if ((data)->crealm == NULL) { e = ENOMEM; goto fail; }
12594p += l; len -= l; ret += l;
12595crealm_oldlen = len;
12596if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12597len = crealm_datalen;
12598e = decode_Realm(p, len, (data)->crealm, &l);
12599if(e) goto fail;
12600p += l; len -= l; ret += l;
12601len = crealm_oldlen - crealm_datalen;
12602}
12603}
12604{
12605size_t cname_datalen, cname_oldlen;
12606Der_type cname_type;
12607e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 8, &cname_datalen, &l);
12608if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
12609if(e) {
12610(data)->cname = NULL;
12611} else {
12612(data)->cname = calloc(1, sizeof(*(data)->cname));
12613if ((data)->cname == NULL) { e = ENOMEM; goto fail; }
12614p += l; len -= l; ret += l;
12615cname_oldlen = len;
12616if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12617len = cname_datalen;
12618e = decode_PrincipalName(p, len, (data)->cname, &l);
12619if(e) goto fail;
12620p += l; len -= l; ret += l;
12621len = cname_oldlen - cname_datalen;
12622}
12623}
12624{
12625size_t realm_datalen, realm_oldlen;
12626Der_type realm_type;
12627e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 9, &realm_datalen, &l);
12628if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
12629if(e) goto fail;
12630p += l; len -= l; ret += l;
12631realm_oldlen = len;
12632if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12633len = realm_datalen;
12634e = decode_Realm(p, len, &(data)->realm, &l);
12635if(e) goto fail;
12636p += l; len -= l; ret += l;
12637len = realm_oldlen - realm_datalen;
12638}
12639{
12640size_t sname_datalen, sname_oldlen;
12641Der_type sname_type;
12642e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sname_type, 10, &sname_datalen, &l);
12643if (e == 0 && sname_type != CONS) { e = ASN1_BAD_ID; }
12644if(e) goto fail;
12645p += l; len -= l; ret += l;
12646sname_oldlen = len;
12647if (sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12648len = sname_datalen;
12649e = decode_PrincipalName(p, len, &(data)->sname, &l);
12650if(e) goto fail;
12651p += l; len -= l; ret += l;
12652len = sname_oldlen - sname_datalen;
12653}
12654{
12655size_t e_text_datalen, e_text_oldlen;
12656Der_type e_text_type;
12657e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &e_text_type, 11, &e_text_datalen, &l);
12658if (e == 0 && e_text_type != CONS) { e = ASN1_BAD_ID; }
12659if(e) {
12660(data)->e_text = NULL;
12661} else {
12662(data)->e_text = calloc(1, sizeof(*(data)->e_text));
12663if ((data)->e_text == NULL) { e = ENOMEM; goto fail; }
12664p += l; len -= l; ret += l;
12665e_text_oldlen = len;
12666if (e_text_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12667len = e_text_datalen;
12668{
12669size_t e_text_Tag_datalen, e_text_Tag_oldlen;
12670Der_type e_text_Tag_type;
12671e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &e_text_Tag_type, UT_GeneralString, &e_text_Tag_datalen, &l);
12672if (e == 0 && e_text_Tag_type != PRIM) { e = ASN1_BAD_ID; }
12673if(e) goto fail;
12674p += l; len -= l; ret += l;
12675e_text_Tag_oldlen = len;
12676if (e_text_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12677len = e_text_Tag_datalen;
12678e = der_get_general_string(p, len, (data)->e_text, &l);
12679if(e) goto fail;
12680p += l; len -= l; ret += l;
12681len = e_text_Tag_oldlen - e_text_Tag_datalen;
12682}
12683len = e_text_oldlen - e_text_datalen;
12684}
12685}
12686{
12687size_t e_data_datalen, e_data_oldlen;
12688Der_type e_data_type;
12689e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &e_data_type, 12, &e_data_datalen, &l);
12690if (e == 0 && e_data_type != CONS) { e = ASN1_BAD_ID; }
12691if(e) {
12692(data)->e_data = NULL;
12693} else {
12694(data)->e_data = calloc(1, sizeof(*(data)->e_data));
12695if ((data)->e_data == NULL) { e = ENOMEM; goto fail; }
12696p += l; len -= l; ret += l;
12697e_data_oldlen = len;
12698if (e_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12699len = e_data_datalen;
12700{
12701size_t e_data_Tag_datalen, e_data_Tag_oldlen;
12702Der_type e_data_Tag_type;
12703e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &e_data_Tag_type, UT_OctetString, &e_data_Tag_datalen, &l);
12704if (e == 0 && e_data_Tag_type != PRIM) { e = ASN1_BAD_ID; }
12705if(e) goto fail;
12706p += l; len -= l; ret += l;
12707e_data_Tag_oldlen = len;
12708if (e_data_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
12709len = e_data_Tag_datalen;
12710e = der_get_octet_string(p, len, (data)->e_data, &l);
12711if(e) goto fail;
12712p += l; len -= l; ret += l;
12713len = e_data_Tag_oldlen - e_data_Tag_datalen;
12714}
12715len = e_data_oldlen - e_data_datalen;
12716}
12717}
12718len = Top_Tag_oldlen - Top_Tag_datalen;
12719}
12720len = Top_oldlen - Top_datalen;
12721}
12722if(size) *size = ret;
12723return 0;
12724fail:
12725free_KRB_ERROR(data);
12726return e;
12727}
12728
12729void ASN1CALL
12730free_KRB_ERROR(KRB_ERROR *data)
12731{
12732free_krb5int32(&(data)->pvno);
12733free_MESSAGE_TYPE(&(data)->msg_type);
12734if((data)->ctime) {
12735free_KerberosTime((data)->ctime);
12736free((data)->ctime);
12737(data)->ctime = NULL;
12738}
12739if((data)->cusec) {
12740free_krb5int32((data)->cusec);
12741free((data)->cusec);
12742(data)->cusec = NULL;
12743}
12744free_KerberosTime(&(data)->stime);
12745free_krb5int32(&(data)->susec);
12746free_krb5int32(&(data)->error_code);
12747if((data)->crealm) {
12748free_Realm((data)->crealm);
12749free((data)->crealm);
12750(data)->crealm = NULL;
12751}
12752if((data)->cname) {
12753free_PrincipalName((data)->cname);
12754free((data)->cname);
12755(data)->cname = NULL;
12756}
12757free_Realm(&(data)->realm);
12758free_PrincipalName(&(data)->sname);
12759if((data)->e_text) {
12760der_free_general_string((data)->e_text);
12761free((data)->e_text);
12762(data)->e_text = NULL;
12763}
12764if((data)->e_data) {
12765der_free_octet_string((data)->e_data);
12766free((data)->e_data);
12767(data)->e_data = NULL;
12768}
12769}
12770
12771size_t ASN1CALL
12772length_KRB_ERROR(const KRB_ERROR *data)
12773{
12774size_t ret = 0;
12775{
12776size_t Top_tag_tag_oldret = ret;
12777ret = 0;
12778ret += length_krb5int32(&(data)->pvno);
12779ret += 1 + der_length_len (ret);
12780ret += Top_tag_tag_oldret;
12781}
12782{
12783size_t Top_tag_tag_oldret = ret;
12784ret = 0;
12785ret += length_MESSAGE_TYPE(&(data)->msg_type);
12786ret += 1 + der_length_len (ret);
12787ret += Top_tag_tag_oldret;
12788}
12789if((data)->ctime){
12790size_t Top_tag_tag_oldret = ret;
12791ret = 0;
12792ret += length_KerberosTime((data)->ctime);
12793ret += 1 + der_length_len (ret);
12794ret += Top_tag_tag_oldret;
12795}
12796if((data)->cusec){
12797size_t Top_tag_tag_oldret = ret;
12798ret = 0;
12799ret += length_krb5int32((data)->cusec);
12800ret += 1 + der_length_len (ret);
12801ret += Top_tag_tag_oldret;
12802}
12803{
12804size_t Top_tag_tag_oldret = ret;
12805ret = 0;
12806ret += length_KerberosTime(&(data)->stime);
12807ret += 1 + der_length_len (ret);
12808ret += Top_tag_tag_oldret;
12809}
12810{
12811size_t Top_tag_tag_oldret = ret;
12812ret = 0;
12813ret += length_krb5int32(&(data)->susec);
12814ret += 1 + der_length_len (ret);
12815ret += Top_tag_tag_oldret;
12816}
12817{
12818size_t Top_tag_tag_oldret = ret;
12819ret = 0;
12820ret += length_krb5int32(&(data)->error_code);
12821ret += 1 + der_length_len (ret);
12822ret += Top_tag_tag_oldret;
12823}
12824if((data)->crealm){
12825size_t Top_tag_tag_oldret = ret;
12826ret = 0;
12827ret += length_Realm((data)->crealm);
12828ret += 1 + der_length_len (ret);
12829ret += Top_tag_tag_oldret;
12830}
12831if((data)->cname){
12832size_t Top_tag_tag_oldret = ret;
12833ret = 0;
12834ret += length_PrincipalName((data)->cname);
12835ret += 1 + der_length_len (ret);
12836ret += Top_tag_tag_oldret;
12837}
12838{
12839size_t Top_tag_tag_oldret = ret;
12840ret = 0;
12841ret += length_Realm(&(data)->realm);
12842ret += 1 + der_length_len (ret);
12843ret += Top_tag_tag_oldret;
12844}
12845{
12846size_t Top_tag_tag_oldret = ret;
12847ret = 0;
12848ret += length_PrincipalName(&(data)->sname);
12849ret += 1 + der_length_len (ret);
12850ret += Top_tag_tag_oldret;
12851}
12852if((data)->e_text){
12853size_t Top_tag_tag_oldret = ret;
12854ret = 0;
12855ret += der_length_general_string((data)->e_text);
12856ret += 1 + der_length_len (ret);
12857ret += 1 + der_length_len (ret);
12858ret += Top_tag_tag_oldret;
12859}
12860if((data)->e_data){
12861size_t Top_tag_tag_oldret = ret;
12862ret = 0;
12863ret += der_length_octet_string((data)->e_data);
12864ret += 1 + der_length_len (ret);
12865ret += 1 + der_length_len (ret);
12866ret += Top_tag_tag_oldret;
12867}
12868ret += 1 + der_length_len (ret);
12869ret += 1 + der_length_len (ret);
12870return ret;
12871}
12872
12873int ASN1CALL
12874copy_KRB_ERROR(const KRB_ERROR *from, KRB_ERROR *to)
12875{
12876memset(to, 0, sizeof(*to));
12877if(copy_krb5int32(&(from)->pvno, &(to)->pvno)) goto fail;
12878if(copy_MESSAGE_TYPE(&(from)->msg_type, &(to)->msg_type)) goto fail;
12879if((from)->ctime) {
12880(to)->ctime = malloc(sizeof(*(to)->ctime));
12881if((to)->ctime == NULL) goto fail;
12882if(copy_KerberosTime((from)->ctime, (to)->ctime)) goto fail;
12883}else
12884(to)->ctime = NULL;
12885if((from)->cusec) {
12886(to)->cusec = malloc(sizeof(*(to)->cusec));
12887if((to)->cusec == NULL) goto fail;
12888if(copy_krb5int32((from)->cusec, (to)->cusec)) goto fail;
12889}else
12890(to)->cusec = NULL;
12891if(copy_KerberosTime(&(from)->stime, &(to)->stime)) goto fail;
12892if(copy_krb5int32(&(from)->susec, &(to)->susec)) goto fail;
12893if(copy_krb5int32(&(from)->error_code, &(to)->error_code)) goto fail;
12894if((from)->crealm) {
12895(to)->crealm = malloc(sizeof(*(to)->crealm));
12896if((to)->crealm == NULL) goto fail;
12897if(copy_Realm((from)->crealm, (to)->crealm)) goto fail;
12898}else
12899(to)->crealm = NULL;
12900if((from)->cname) {
12901(to)->cname = malloc(sizeof(*(to)->cname));
12902if((to)->cname == NULL) goto fail;
12903if(copy_PrincipalName((from)->cname, (to)->cname)) goto fail;
12904}else
12905(to)->cname = NULL;
12906if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
12907if(copy_PrincipalName(&(from)->sname, &(to)->sname)) goto fail;
12908if((from)->e_text) {
12909(to)->e_text = malloc(sizeof(*(to)->e_text));
12910if((to)->e_text == NULL) goto fail;
12911if(der_copy_general_string((from)->e_text, (to)->e_text)) goto fail;
12912}else
12913(to)->e_text = NULL;
12914if((from)->e_data) {
12915(to)->e_data = malloc(sizeof(*(to)->e_data));
12916if((to)->e_data == NULL) goto fail;
12917if(der_copy_octet_string((from)->e_data, (to)->e_data)) goto fail;
12918}else
12919(to)->e_data = NULL;
12920return 0;
12921fail:
12922free_KRB_ERROR(to);
12923return ENOMEM;
12924}
12925
12926int ASN1CALL
12927encode_ChangePasswdDataMS(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ChangePasswdDataMS *data, size_t *size)
12928{
12929size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
12930size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12931int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
12932
12933/* targrealm */
12934if((data)->targrealm) {
12935size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12936ret = 0;
12937e = encode_Realm(p, len, (data)->targrealm, &l);
12938if (e) return e;
12939p -= l; len -= l; ret += l;
12940
12941e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
12942if (e) return e;
12943p -= l; len -= l; ret += l;
12944
12945ret += Top_tag_oldret;
12946}
12947/* targname */
12948if((data)->targname) {
12949size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12950ret = 0;
12951e = encode_PrincipalName(p, len, (data)->targname, &l);
12952if (e) return e;
12953p -= l; len -= l; ret += l;
12954
12955e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
12956if (e) return e;
12957p -= l; len -= l; ret += l;
12958
12959ret += Top_tag_oldret;
12960}
12961/* newpasswd */
12962{
12963size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
12964ret = 0;
12965e = der_put_octet_string(p, len, &(data)->newpasswd, &l);
12966if (e) return e;
12967p -= l; len -= l; ret += l;
12968
12969e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
12970if (e) return e;
12971p -= l; len -= l; ret += l;
12972
12973e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
12974if (e) return e;
12975p -= l; len -= l; ret += l;
12976
12977ret += Top_tag_oldret;
12978}
12979e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
12980if (e) return e;
12981p -= l; len -= l; ret += l;
12982
12983*size = ret;
12984return 0;
12985}
12986
12987int ASN1CALL
12988decode_ChangePasswdDataMS(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ChangePasswdDataMS *data, size_t *size)
12989{
12990size_t ret = 0;
12991size_t l HEIMDAL_UNUSED_ATTRIBUTE;
12992int e HEIMDAL_UNUSED_ATTRIBUTE;
12993
12994memset(data, 0, sizeof(*data));
12995{
12996size_t Top_datalen, Top_oldlen;
12997Der_type Top_type;
12998e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
12999if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
13000if(e) goto fail;
13001p += l; len -= l; ret += l;
13002Top_oldlen = len;
13003if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13004len = Top_datalen;
13005{
13006size_t newpasswd_datalen, newpasswd_oldlen;
13007Der_type newpasswd_type;
13008e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &newpasswd_type, 0, &newpasswd_datalen, &l);
13009if (e == 0 && newpasswd_type != CONS) { e = ASN1_BAD_ID; }
13010if(e) goto fail;
13011p += l; len -= l; ret += l;
13012newpasswd_oldlen = len;
13013if (newpasswd_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13014len = newpasswd_datalen;
13015{
13016size_t newpasswd_Tag_datalen, newpasswd_Tag_oldlen;
13017Der_type newpasswd_Tag_type;
13018e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &newpasswd_Tag_type, UT_OctetString, &newpasswd_Tag_datalen, &l);
13019if (e == 0 && newpasswd_Tag_type != PRIM) { e = ASN1_BAD_ID; }
13020if(e) goto fail;
13021p += l; len -= l; ret += l;
13022newpasswd_Tag_oldlen = len;
13023if (newpasswd_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13024len = newpasswd_Tag_datalen;
13025e = der_get_octet_string(p, len, &(data)->newpasswd, &l);
13026if(e) goto fail;
13027p += l; len -= l; ret += l;
13028len = newpasswd_Tag_oldlen - newpasswd_Tag_datalen;
13029}
13030len = newpasswd_oldlen - newpasswd_datalen;
13031}
13032{
13033size_t targname_datalen, targname_oldlen;
13034Der_type targname_type;
13035e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targname_type, 1, &targname_datalen, &l);
13036if (e == 0 && targname_type != CONS) { e = ASN1_BAD_ID; }
13037if(e) {
13038(data)->targname = NULL;
13039} else {
13040(data)->targname = calloc(1, sizeof(*(data)->targname));
13041if ((data)->targname == NULL) { e = ENOMEM; goto fail; }
13042p += l; len -= l; ret += l;
13043targname_oldlen = len;
13044if (targname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13045len = targname_datalen;
13046e = decode_PrincipalName(p, len, (data)->targname, &l);
13047if(e) goto fail;
13048p += l; len -= l; ret += l;
13049len = targname_oldlen - targname_datalen;
13050}
13051}
13052{
13053size_t targrealm_datalen, targrealm_oldlen;
13054Der_type targrealm_type;
13055e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &targrealm_type, 2, &targrealm_datalen, &l);
13056if (e == 0 && targrealm_type != CONS) { e = ASN1_BAD_ID; }
13057if(e) {
13058(data)->targrealm = NULL;
13059} else {
13060(data)->targrealm = calloc(1, sizeof(*(data)->targrealm));
13061if ((data)->targrealm == NULL) { e = ENOMEM; goto fail; }
13062p += l; len -= l; ret += l;
13063targrealm_oldlen = len;
13064if (targrealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13065len = targrealm_datalen;
13066e = decode_Realm(p, len, (data)->targrealm, &l);
13067if(e) goto fail;
13068p += l; len -= l; ret += l;
13069len = targrealm_oldlen - targrealm_datalen;
13070}
13071}
13072len = Top_oldlen - Top_datalen;
13073}
13074if(size) *size = ret;
13075return 0;
13076fail:
13077free_ChangePasswdDataMS(data);
13078return e;
13079}
13080
13081void ASN1CALL
13082free_ChangePasswdDataMS(ChangePasswdDataMS *data)
13083{
13084der_free_octet_string(&(data)->newpasswd);
13085if((data)->targname) {
13086free_PrincipalName((data)->targname);
13087free((data)->targname);
13088(data)->targname = NULL;
13089}
13090if((data)->targrealm) {
13091free_Realm((data)->targrealm);
13092free((data)->targrealm);
13093(data)->targrealm = NULL;
13094}
13095}
13096
13097size_t ASN1CALL
13098length_ChangePasswdDataMS(const ChangePasswdDataMS *data)
13099{
13100size_t ret = 0;
13101{
13102size_t Top_tag_oldret = ret;
13103ret = 0;
13104ret += der_length_octet_string(&(data)->newpasswd);
13105ret += 1 + der_length_len (ret);
13106ret += 1 + der_length_len (ret);
13107ret += Top_tag_oldret;
13108}
13109if((data)->targname){
13110size_t Top_tag_oldret = ret;
13111ret = 0;
13112ret += length_PrincipalName((data)->targname);
13113ret += 1 + der_length_len (ret);
13114ret += Top_tag_oldret;
13115}
13116if((data)->targrealm){
13117size_t Top_tag_oldret = ret;
13118ret = 0;
13119ret += length_Realm((data)->targrealm);
13120ret += 1 + der_length_len (ret);
13121ret += Top_tag_oldret;
13122}
13123ret += 1 + der_length_len (ret);
13124return ret;
13125}
13126
13127int ASN1CALL
13128copy_ChangePasswdDataMS(const ChangePasswdDataMS *from, ChangePasswdDataMS *to)
13129{
13130memset(to, 0, sizeof(*to));
13131if(der_copy_octet_string(&(from)->newpasswd, &(to)->newpasswd)) goto fail;
13132if((from)->targname) {
13133(to)->targname = malloc(sizeof(*(to)->targname));
13134if((to)->targname == NULL) goto fail;
13135if(copy_PrincipalName((from)->targname, (to)->targname)) goto fail;
13136}else
13137(to)->targname = NULL;
13138if((from)->targrealm) {
13139(to)->targrealm = malloc(sizeof(*(to)->targrealm));
13140if((to)->targrealm == NULL) goto fail;
13141if(copy_Realm((from)->targrealm, (to)->targrealm)) goto fail;
13142}else
13143(to)->targrealm = NULL;
13144return 0;
13145fail:
13146free_ChangePasswdDataMS(to);
13147return ENOMEM;
13148}
13149
13150int ASN1CALL
13151encode_EtypeList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EtypeList *data, size_t *size)
13152{
13153size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13154size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13155int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13156
13157for(i = (int)(data)->len - 1; i >= 0; --i) {
13158size_t Top_tag_for_oldret = ret;
13159ret = 0;
13160e = encode_ENCTYPE(p, len, &(data)->val[i], &l);
13161if (e) return e;
13162p -= l; len -= l; ret += l;
13163
13164ret += Top_tag_for_oldret;
13165}
13166e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
13167if (e) return e;
13168p -= l; len -= l; ret += l;
13169
13170*size = ret;
13171return 0;
13172}
13173
13174int ASN1CALL
13175decode_EtypeList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EtypeList *data, size_t *size)
13176{
13177size_t ret = 0;
13178size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13179int e HEIMDAL_UNUSED_ATTRIBUTE;
13180
13181memset(data, 0, sizeof(*data));
13182{
13183size_t Top_datalen, Top_oldlen;
13184Der_type Top_type;
13185e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
13186if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
13187if(e) goto fail;
13188p += l; len -= l; ret += l;
13189Top_oldlen = len;
13190if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13191len = Top_datalen;
13192{
13193size_t Top_Tag_origlen = len;
13194size_t Top_Tag_oldret = ret;
13195size_t Top_Tag_olen = 0;
13196void *Top_Tag_tmp;
13197ret = 0;
13198(data)->len = 0;
13199(data)->val = NULL;
13200while(ret < Top_Tag_origlen) {
13201size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
13202if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
13203Top_Tag_olen = Top_Tag_nlen;
13204Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
13205if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
13206(data)->val = Top_Tag_tmp;
13207e = decode_ENCTYPE(p, len, &(data)->val[(data)->len], &l);
13208if(e) goto fail;
13209p += l; len -= l; ret += l;
13210(data)->len++;
13211len = Top_Tag_origlen - ret;
13212}
13213ret += Top_Tag_oldret;
13214}
13215len = Top_oldlen - Top_datalen;
13216}
13217if(size) *size = ret;
13218return 0;
13219fail:
13220free_EtypeList(data);
13221return e;
13222}
13223
13224void ASN1CALL
13225free_EtypeList(EtypeList *data)
13226{
13227while((data)->len){
13228free_ENCTYPE(&(data)->val[(data)->len-1]);
13229(data)->len--;
13230}
13231free((data)->val);
13232(data)->val = NULL;
13233}
13234
13235size_t ASN1CALL
13236length_EtypeList(const EtypeList *data)
13237{
13238size_t ret = 0;
13239{
13240size_t Top_tag_oldret = ret;
13241unsigned int n_Top_tag;
13242ret = 0;
13243for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
13244size_t Top_tag_for_oldret = ret;
13245ret = 0;
13246ret += length_ENCTYPE(&(data)->val[n_Top_tag - 1]);
13247ret += Top_tag_for_oldret;
13248}
13249ret += Top_tag_oldret;
13250}
13251ret += 1 + der_length_len (ret);
13252return ret;
13253}
13254
13255int ASN1CALL
13256copy_EtypeList(const EtypeList *from, EtypeList *to)
13257{
13258memset(to, 0, sizeof(*to));
13259if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
13260goto fail;
13261for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
13262if(copy_ENCTYPE(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
13263}
13264return 0;
13265fail:
13266free_EtypeList(to);
13267return ENOMEM;
13268}
13269
13270int ASN1CALL
13271encode_AD_IF_RELEVANT(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_IF_RELEVANT *data, size_t *size)
13272{
13273size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13274size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13275int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13276
13277e = encode_AuthorizationData(p, len, data, &l);
13278if (e) return e;
13279p -= l; len -= l; ret += l;
13280
13281*size = ret;
13282return 0;
13283}
13284
13285int ASN1CALL
13286decode_AD_IF_RELEVANT(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_IF_RELEVANT *data, size_t *size)
13287{
13288size_t ret = 0;
13289size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13290int e HEIMDAL_UNUSED_ATTRIBUTE;
13291
13292memset(data, 0, sizeof(*data));
13293e = decode_AuthorizationData(p, len, data, &l);
13294if(e) goto fail;
13295p += l; len -= l; ret += l;
13296if(size) *size = ret;
13297return 0;
13298fail:
13299free_AD_IF_RELEVANT(data);
13300return e;
13301}
13302
13303void ASN1CALL
13304free_AD_IF_RELEVANT(AD_IF_RELEVANT *data)
13305{
13306free_AuthorizationData(data);
13307}
13308
13309size_t ASN1CALL
13310length_AD_IF_RELEVANT(const AD_IF_RELEVANT *data)
13311{
13312size_t ret = 0;
13313ret += length_AuthorizationData(data);
13314return ret;
13315}
13316
13317int ASN1CALL
13318copy_AD_IF_RELEVANT(const AD_IF_RELEVANT *from, AD_IF_RELEVANT *to)
13319{
13320memset(to, 0, sizeof(*to));
13321if(copy_AuthorizationData(from, to)) goto fail;
13322return 0;
13323fail:
13324free_AD_IF_RELEVANT(to);
13325return ENOMEM;
13326}
13327
13328int ASN1CALL
13329encode_AD_KDCIssued(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_KDCIssued *data, size_t *size)
13330{
13331size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13332size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13333int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13334
13335/* elements */
13336{
13337size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13338ret = 0;
13339e = encode_AuthorizationData(p, len, &(data)->elements, &l);
13340if (e) return e;
13341p -= l; len -= l; ret += l;
13342
13343e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
13344if (e) return e;
13345p -= l; len -= l; ret += l;
13346
13347ret += Top_tag_oldret;
13348}
13349/* i-sname */
13350if((data)->i_sname) {
13351size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13352ret = 0;
13353e = encode_PrincipalName(p, len, (data)->i_sname, &l);
13354if (e) return e;
13355p -= l; len -= l; ret += l;
13356
13357e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
13358if (e) return e;
13359p -= l; len -= l; ret += l;
13360
13361ret += Top_tag_oldret;
13362}
13363/* i-realm */
13364if((data)->i_realm) {
13365size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13366ret = 0;
13367e = encode_Realm(p, len, (data)->i_realm, &l);
13368if (e) return e;
13369p -= l; len -= l; ret += l;
13370
13371e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
13372if (e) return e;
13373p -= l; len -= l; ret += l;
13374
13375ret += Top_tag_oldret;
13376}
13377/* ad-checksum */
13378{
13379size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13380ret = 0;
13381e = encode_Checksum(p, len, &(data)->ad_checksum, &l);
13382if (e) return e;
13383p -= l; len -= l; ret += l;
13384
13385e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
13386if (e) return e;
13387p -= l; len -= l; ret += l;
13388
13389ret += Top_tag_oldret;
13390}
13391e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
13392if (e) return e;
13393p -= l; len -= l; ret += l;
13394
13395*size = ret;
13396return 0;
13397}
13398
13399int ASN1CALL
13400decode_AD_KDCIssued(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_KDCIssued *data, size_t *size)
13401{
13402size_t ret = 0;
13403size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13404int e HEIMDAL_UNUSED_ATTRIBUTE;
13405
13406memset(data, 0, sizeof(*data));
13407{
13408size_t Top_datalen, Top_oldlen;
13409Der_type Top_type;
13410e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
13411if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
13412if(e) goto fail;
13413p += l; len -= l; ret += l;
13414Top_oldlen = len;
13415if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13416len = Top_datalen;
13417{
13418size_t ad_checksum_datalen, ad_checksum_oldlen;
13419Der_type ad_checksum_type;
13420e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ad_checksum_type, 0, &ad_checksum_datalen, &l);
13421if (e == 0 && ad_checksum_type != CONS) { e = ASN1_BAD_ID; }
13422if(e) goto fail;
13423p += l; len -= l; ret += l;
13424ad_checksum_oldlen = len;
13425if (ad_checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13426len = ad_checksum_datalen;
13427e = decode_Checksum(p, len, &(data)->ad_checksum, &l);
13428if(e) goto fail;
13429p += l; len -= l; ret += l;
13430len = ad_checksum_oldlen - ad_checksum_datalen;
13431}
13432{
13433size_t i_realm_datalen, i_realm_oldlen;
13434Der_type i_realm_type;
13435e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &i_realm_type, 1, &i_realm_datalen, &l);
13436if (e == 0 && i_realm_type != CONS) { e = ASN1_BAD_ID; }
13437if(e) {
13438(data)->i_realm = NULL;
13439} else {
13440(data)->i_realm = calloc(1, sizeof(*(data)->i_realm));
13441if ((data)->i_realm == NULL) { e = ENOMEM; goto fail; }
13442p += l; len -= l; ret += l;
13443i_realm_oldlen = len;
13444if (i_realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13445len = i_realm_datalen;
13446e = decode_Realm(p, len, (data)->i_realm, &l);
13447if(e) goto fail;
13448p += l; len -= l; ret += l;
13449len = i_realm_oldlen - i_realm_datalen;
13450}
13451}
13452{
13453size_t i_sname_datalen, i_sname_oldlen;
13454Der_type i_sname_type;
13455e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &i_sname_type, 2, &i_sname_datalen, &l);
13456if (e == 0 && i_sname_type != CONS) { e = ASN1_BAD_ID; }
13457if(e) {
13458(data)->i_sname = NULL;
13459} else {
13460(data)->i_sname = calloc(1, sizeof(*(data)->i_sname));
13461if ((data)->i_sname == NULL) { e = ENOMEM; goto fail; }
13462p += l; len -= l; ret += l;
13463i_sname_oldlen = len;
13464if (i_sname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13465len = i_sname_datalen;
13466e = decode_PrincipalName(p, len, (data)->i_sname, &l);
13467if(e) goto fail;
13468p += l; len -= l; ret += l;
13469len = i_sname_oldlen - i_sname_datalen;
13470}
13471}
13472{
13473size_t elements_datalen, elements_oldlen;
13474Der_type elements_type;
13475e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &elements_type, 3, &elements_datalen, &l);
13476if (e == 0 && elements_type != CONS) { e = ASN1_BAD_ID; }
13477if(e) goto fail;
13478p += l; len -= l; ret += l;
13479elements_oldlen = len;
13480if (elements_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13481len = elements_datalen;
13482e = decode_AuthorizationData(p, len, &(data)->elements, &l);
13483if(e) goto fail;
13484p += l; len -= l; ret += l;
13485len = elements_oldlen - elements_datalen;
13486}
13487len = Top_oldlen - Top_datalen;
13488}
13489if(size) *size = ret;
13490return 0;
13491fail:
13492free_AD_KDCIssued(data);
13493return e;
13494}
13495
13496void ASN1CALL
13497free_AD_KDCIssued(AD_KDCIssued *data)
13498{
13499free_Checksum(&(data)->ad_checksum);
13500if((data)->i_realm) {
13501free_Realm((data)->i_realm);
13502free((data)->i_realm);
13503(data)->i_realm = NULL;
13504}
13505if((data)->i_sname) {
13506free_PrincipalName((data)->i_sname);
13507free((data)->i_sname);
13508(data)->i_sname = NULL;
13509}
13510free_AuthorizationData(&(data)->elements);
13511}
13512
13513size_t ASN1CALL
13514length_AD_KDCIssued(const AD_KDCIssued *data)
13515{
13516size_t ret = 0;
13517{
13518size_t Top_tag_oldret = ret;
13519ret = 0;
13520ret += length_Checksum(&(data)->ad_checksum);
13521ret += 1 + der_length_len (ret);
13522ret += Top_tag_oldret;
13523}
13524if((data)->i_realm){
13525size_t Top_tag_oldret = ret;
13526ret = 0;
13527ret += length_Realm((data)->i_realm);
13528ret += 1 + der_length_len (ret);
13529ret += Top_tag_oldret;
13530}
13531if((data)->i_sname){
13532size_t Top_tag_oldret = ret;
13533ret = 0;
13534ret += length_PrincipalName((data)->i_sname);
13535ret += 1 + der_length_len (ret);
13536ret += Top_tag_oldret;
13537}
13538{
13539size_t Top_tag_oldret = ret;
13540ret = 0;
13541ret += length_AuthorizationData(&(data)->elements);
13542ret += 1 + der_length_len (ret);
13543ret += Top_tag_oldret;
13544}
13545ret += 1 + der_length_len (ret);
13546return ret;
13547}
13548
13549int ASN1CALL
13550copy_AD_KDCIssued(const AD_KDCIssued *from, AD_KDCIssued *to)
13551{
13552memset(to, 0, sizeof(*to));
13553if(copy_Checksum(&(from)->ad_checksum, &(to)->ad_checksum)) goto fail;
13554if((from)->i_realm) {
13555(to)->i_realm = malloc(sizeof(*(to)->i_realm));
13556if((to)->i_realm == NULL) goto fail;
13557if(copy_Realm((from)->i_realm, (to)->i_realm)) goto fail;
13558}else
13559(to)->i_realm = NULL;
13560if((from)->i_sname) {
13561(to)->i_sname = malloc(sizeof(*(to)->i_sname));
13562if((to)->i_sname == NULL) goto fail;
13563if(copy_PrincipalName((from)->i_sname, (to)->i_sname)) goto fail;
13564}else
13565(to)->i_sname = NULL;
13566if(copy_AuthorizationData(&(from)->elements, &(to)->elements)) goto fail;
13567return 0;
13568fail:
13569free_AD_KDCIssued(to);
13570return ENOMEM;
13571}
13572
13573int ASN1CALL
13574encode_AD_AND_OR(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_AND_OR *data, size_t *size)
13575{
13576size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13577size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13578int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13579
13580/* elements */
13581{
13582size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13583ret = 0;
13584e = encode_AuthorizationData(p, len, &(data)->elements, &l);
13585if (e) return e;
13586p -= l; len -= l; ret += l;
13587
13588e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
13589if (e) return e;
13590p -= l; len -= l; ret += l;
13591
13592ret += Top_tag_oldret;
13593}
13594/* condition-count */
13595{
13596size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
13597ret = 0;
13598e = der_put_heim_integer(p, len, &(data)->condition_count, &l);
13599if (e) return e;
13600p -= l; len -= l; ret += l;
13601
13602e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
13603if (e) return e;
13604p -= l; len -= l; ret += l;
13605
13606e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
13607if (e) return e;
13608p -= l; len -= l; ret += l;
13609
13610ret += Top_tag_oldret;
13611}
13612e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
13613if (e) return e;
13614p -= l; len -= l; ret += l;
13615
13616*size = ret;
13617return 0;
13618}
13619
13620int ASN1CALL
13621decode_AD_AND_OR(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_AND_OR *data, size_t *size)
13622{
13623size_t ret = 0;
13624size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13625int e HEIMDAL_UNUSED_ATTRIBUTE;
13626
13627memset(data, 0, sizeof(*data));
13628{
13629size_t Top_datalen, Top_oldlen;
13630Der_type Top_type;
13631e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
13632if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
13633if(e) goto fail;
13634p += l; len -= l; ret += l;
13635Top_oldlen = len;
13636if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13637len = Top_datalen;
13638{
13639size_t condition_count_datalen, condition_count_oldlen;
13640Der_type condition_count_type;
13641e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &condition_count_type, 0, &condition_count_datalen, &l);
13642if (e == 0 && condition_count_type != CONS) { e = ASN1_BAD_ID; }
13643if(e) goto fail;
13644p += l; len -= l; ret += l;
13645condition_count_oldlen = len;
13646if (condition_count_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13647len = condition_count_datalen;
13648{
13649size_t condition_count_Tag_datalen, condition_count_Tag_oldlen;
13650Der_type condition_count_Tag_type;
13651e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &condition_count_Tag_type, UT_Integer, &condition_count_Tag_datalen, &l);
13652if (e == 0 && condition_count_Tag_type != PRIM) { e = ASN1_BAD_ID; }
13653if(e) goto fail;
13654p += l; len -= l; ret += l;
13655condition_count_Tag_oldlen = len;
13656if (condition_count_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13657len = condition_count_Tag_datalen;
13658e = der_get_heim_integer(p, len, &(data)->condition_count, &l);
13659if(e) goto fail;
13660p += l; len -= l; ret += l;
13661len = condition_count_Tag_oldlen - condition_count_Tag_datalen;
13662}
13663len = condition_count_oldlen - condition_count_datalen;
13664}
13665{
13666size_t elements_datalen, elements_oldlen;
13667Der_type elements_type;
13668e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &elements_type, 1, &elements_datalen, &l);
13669if (e == 0 && elements_type != CONS) { e = ASN1_BAD_ID; }
13670if(e) goto fail;
13671p += l; len -= l; ret += l;
13672elements_oldlen = len;
13673if (elements_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13674len = elements_datalen;
13675e = decode_AuthorizationData(p, len, &(data)->elements, &l);
13676if(e) goto fail;
13677p += l; len -= l; ret += l;
13678len = elements_oldlen - elements_datalen;
13679}
13680len = Top_oldlen - Top_datalen;
13681}
13682if(size) *size = ret;
13683return 0;
13684fail:
13685free_AD_AND_OR(data);
13686return e;
13687}
13688
13689void ASN1CALL
13690free_AD_AND_OR(AD_AND_OR *data)
13691{
13692der_free_heim_integer(&(data)->condition_count);
13693free_AuthorizationData(&(data)->elements);
13694}
13695
13696size_t ASN1CALL
13697length_AD_AND_OR(const AD_AND_OR *data)
13698{
13699size_t ret = 0;
13700{
13701size_t Top_tag_oldret = ret;
13702ret = 0;
13703ret += der_length_heim_integer(&(data)->condition_count);
13704ret += 1 + der_length_len (ret);
13705ret += 1 + der_length_len (ret);
13706ret += Top_tag_oldret;
13707}
13708{
13709size_t Top_tag_oldret = ret;
13710ret = 0;
13711ret += length_AuthorizationData(&(data)->elements);
13712ret += 1 + der_length_len (ret);
13713ret += Top_tag_oldret;
13714}
13715ret += 1 + der_length_len (ret);
13716return ret;
13717}
13718
13719int ASN1CALL
13720copy_AD_AND_OR(const AD_AND_OR *from, AD_AND_OR *to)
13721{
13722memset(to, 0, sizeof(*to));
13723if(der_copy_heim_integer(&(from)->condition_count, &(to)->condition_count)) goto fail;
13724if(copy_AuthorizationData(&(from)->elements, &(to)->elements)) goto fail;
13725return 0;
13726fail:
13727free_AD_AND_OR(to);
13728return ENOMEM;
13729}
13730
13731int ASN1CALL
13732encode_AD_MANDATORY_FOR_KDC(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_MANDATORY_FOR_KDC *data, size_t *size)
13733{
13734size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13735size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13736int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13737
13738e = encode_AuthorizationData(p, len, data, &l);
13739if (e) return e;
13740p -= l; len -= l; ret += l;
13741
13742*size = ret;
13743return 0;
13744}
13745
13746int ASN1CALL
13747decode_AD_MANDATORY_FOR_KDC(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_MANDATORY_FOR_KDC *data, size_t *size)
13748{
13749size_t ret = 0;
13750size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13751int e HEIMDAL_UNUSED_ATTRIBUTE;
13752
13753memset(data, 0, sizeof(*data));
13754e = decode_AuthorizationData(p, len, data, &l);
13755if(e) goto fail;
13756p += l; len -= l; ret += l;
13757if(size) *size = ret;
13758return 0;
13759fail:
13760free_AD_MANDATORY_FOR_KDC(data);
13761return e;
13762}
13763
13764void ASN1CALL
13765free_AD_MANDATORY_FOR_KDC(AD_MANDATORY_FOR_KDC *data)
13766{
13767free_AuthorizationData(data);
13768}
13769
13770size_t ASN1CALL
13771length_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *data)
13772{
13773size_t ret = 0;
13774ret += length_AuthorizationData(data);
13775return ret;
13776}
13777
13778int ASN1CALL
13779copy_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *from, AD_MANDATORY_FOR_KDC *to)
13780{
13781memset(to, 0, sizeof(*to));
13782if(copy_AuthorizationData(from, to)) goto fail;
13783return 0;
13784fail:
13785free_AD_MANDATORY_FOR_KDC(to);
13786return ENOMEM;
13787}
13788
13789int ASN1CALL
13790encode_PA_SAM_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_TYPE *data, size_t *size)
13791{
13792size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13793size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13794int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13795
13796{
13797int enumint = (int)*data;
13798e = der_put_integer(p, len, &enumint, &l);
13799if (e) return e;
13800p -= l; len -= l; ret += l;
13801
13802}
13803;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
13804if (e) return e;
13805p -= l; len -= l; ret += l;
13806
13807*size = ret;
13808return 0;
13809}
13810
13811int ASN1CALL
13812decode_PA_SAM_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_TYPE *data, size_t *size)
13813{
13814size_t ret = 0;
13815size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13816int e HEIMDAL_UNUSED_ATTRIBUTE;
13817
13818memset(data, 0, sizeof(*data));
13819{
13820size_t Top_datalen, Top_oldlen;
13821Der_type Top_type;
13822e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
13823if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
13824if(e) goto fail;
13825p += l; len -= l; ret += l;
13826Top_oldlen = len;
13827if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13828len = Top_datalen;
13829{
13830int enumint;
13831e = der_get_integer(p, len, &enumint, &l);
13832if(e) goto fail;
13833p += l; len -= l; ret += l;
13834*data = enumint;
13835}
13836len = Top_oldlen - Top_datalen;
13837}
13838if(size) *size = ret;
13839return 0;
13840fail:
13841free_PA_SAM_TYPE(data);
13842return e;
13843}
13844
13845void ASN1CALL
13846free_PA_SAM_TYPE(PA_SAM_TYPE *data)
13847{
13848}
13849
13850size_t ASN1CALL
13851length_PA_SAM_TYPE(const PA_SAM_TYPE *data)
13852{
13853size_t ret = 0;
13854{
13855int enumint = *data;
13856ret += der_length_integer(&enumint);
13857}
13858ret += 1 + der_length_len (ret);
13859return ret;
13860}
13861
13862int ASN1CALL
13863copy_PA_SAM_TYPE(const PA_SAM_TYPE *from, PA_SAM_TYPE *to)
13864{
13865memset(to, 0, sizeof(*to));
13866*(to) = *(from);
13867return 0;
13868}
13869
13870int ASN1CALL
13871encode_PA_SAM_REDIRECT(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_REDIRECT *data, size_t *size)
13872{
13873size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13874size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13875int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13876
13877e = encode_HostAddresses(p, len, data, &l);
13878if (e) return e;
13879p -= l; len -= l; ret += l;
13880
13881*size = ret;
13882return 0;
13883}
13884
13885int ASN1CALL
13886decode_PA_SAM_REDIRECT(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_REDIRECT *data, size_t *size)
13887{
13888size_t ret = 0;
13889size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13890int e HEIMDAL_UNUSED_ATTRIBUTE;
13891
13892memset(data, 0, sizeof(*data));
13893e = decode_HostAddresses(p, len, data, &l);
13894if(e) goto fail;
13895p += l; len -= l; ret += l;
13896if(size) *size = ret;
13897return 0;
13898fail:
13899free_PA_SAM_REDIRECT(data);
13900return e;
13901}
13902
13903void ASN1CALL
13904free_PA_SAM_REDIRECT(PA_SAM_REDIRECT *data)
13905{
13906free_HostAddresses(data);
13907}
13908
13909size_t ASN1CALL
13910length_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *data)
13911{
13912size_t ret = 0;
13913ret += length_HostAddresses(data);
13914return ret;
13915}
13916
13917int ASN1CALL
13918copy_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *from, PA_SAM_REDIRECT *to)
13919{
13920memset(to, 0, sizeof(*to));
13921if(copy_HostAddresses(from, to)) goto fail;
13922return 0;
13923fail:
13924free_PA_SAM_REDIRECT(to);
13925return ENOMEM;
13926}
13927
13928int ASN1CALL
13929encode_SAMFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SAMFlags *data, size_t *size)
13930{
13931size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
13932size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13933int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
13934
13935{
13936unsigned char c = 0;
13937if (len < 1) return ASN1_OVERFLOW;
13938*p-- = c; len--; ret++;
13939c = 0;
13940if (len < 1) return ASN1_OVERFLOW;
13941*p-- = c; len--; ret++;
13942c = 0;
13943if (len < 1) return ASN1_OVERFLOW;
13944*p-- = c; len--; ret++;
13945c = 0;
13946if((data)->must_pk_encrypt_sad) {
13947c |= 1<<5;
13948}
13949if((data)->send_encrypted_sad) {
13950c |= 1<<6;
13951}
13952if((data)->use_sad_as_key) {
13953c |= 1<<7;
13954}
13955if (len < 1) return ASN1_OVERFLOW;
13956*p-- = c; len--; ret++;
13957if (len < 1) return ASN1_OVERFLOW;
13958*p-- = 0;
13959len -= 1;
13960ret += 1;
13961}
13962
13963e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
13964if (e) return e;
13965p -= l; len -= l; ret += l;
13966
13967*size = ret;
13968return 0;
13969}
13970
13971int ASN1CALL
13972decode_SAMFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SAMFlags *data, size_t *size)
13973{
13974size_t ret = 0;
13975size_t l HEIMDAL_UNUSED_ATTRIBUTE;
13976int e HEIMDAL_UNUSED_ATTRIBUTE;
13977
13978memset(data, 0, sizeof(*data));
13979{
13980size_t Top_datalen, Top_oldlen;
13981Der_type Top_type;
13982e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
13983if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
13984if(e) goto fail;
13985p += l; len -= l; ret += l;
13986Top_oldlen = len;
13987if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
13988len = Top_datalen;
13989if (len < 1) return ASN1_OVERRUN;
13990p++; len--; ret++;
13991do {
13992if (len < 1) break;
13993(data)->use_sad_as_key = (*p >> 7) & 1;
13994(data)->send_encrypted_sad = (*p >> 6) & 1;
13995(data)->must_pk_encrypt_sad = (*p >> 5) & 1;
13996} while(0);
13997p += len; ret += len;
13998len = Top_oldlen - Top_datalen;
13999}
14000if(size) *size = ret;
14001return 0;
14002fail:
14003free_SAMFlags(data);
14004return e;
14005}
14006
14007void ASN1CALL
14008free_SAMFlags(SAMFlags *data)
14009{
14010}
14011
14012size_t ASN1CALL
14013length_SAMFlags(const SAMFlags *data)
14014{
14015size_t ret = 0;
14016ret += 5;
14017ret += 1 + der_length_len (ret);
14018return ret;
14019}
14020
14021int ASN1CALL
14022copy_SAMFlags(const SAMFlags *from, SAMFlags *to)
14023{
14024memset(to, 0, sizeof(*to));
14025*(to) = *(from);
14026return 0;
14027}
14028
14029unsigned SAMFlags2int(SAMFlags f)
14030{
14031unsigned r = 0;
14032if(f.use_sad_as_key) r |= (1U << 0);
14033if(f.send_encrypted_sad) r |= (1U << 1);
14034if(f.must_pk_encrypt_sad) r |= (1U << 2);
14035return r;
14036}
14037
14038SAMFlags int2SAMFlags(unsigned n)
14039{
14040 SAMFlags flags;
14041
14042 memset(&flags, 0, sizeof(flags));
14043
14044 flags.use_sad_as_key = (n >> 0) & 1;
14045 flags.send_encrypted_sad = (n >> 1) & 1;
14046 flags.must_pk_encrypt_sad = (n >> 2) & 1;
14047 return flags;
14048}
14049
14050static struct units SAMFlags_units[] = {
14051 {"must-pk-encrypt-sad", 1U << 2},
14052 {"send-encrypted-sad", 1U << 1},
14053 {"use-sad-as-key", 1U << 0},
14054 {NULL, 0}
14055};
14056
14057const struct units * asn1_SAMFlags_units(void){
14058return SAMFlags_units;
14059}
14060
14061int ASN1CALL
14062encode_PA_SAM_CHALLENGE_2_BODY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_CHALLENGE_2_BODY *data, size_t *size)
14063{
14064size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
14065size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14066int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
14067
14068/* sam-etype */
14069{
14070size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14071ret = 0;
14072e = encode_krb5int32(p, len, &(data)->sam_etype, &l);
14073if (e) return e;
14074p -= l; len -= l; ret += l;
14075
14076e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
14077if (e) return e;
14078p -= l; len -= l; ret += l;
14079
14080ret += Top_tag_oldret;
14081}
14082/* sam-nonce */
14083{
14084size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14085ret = 0;
14086e = encode_krb5int32(p, len, &(data)->sam_nonce, &l);
14087if (e) return e;
14088p -= l; len -= l; ret += l;
14089
14090e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
14091if (e) return e;
14092p -= l; len -= l; ret += l;
14093
14094ret += Top_tag_oldret;
14095}
14096/* sam-pk-for-sad */
14097if((data)->sam_pk_for_sad) {
14098size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14099ret = 0;
14100e = encode_EncryptionKey(p, len, (data)->sam_pk_for_sad, &l);
14101if (e) return e;
14102p -= l; len -= l; ret += l;
14103
14104e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
14105if (e) return e;
14106p -= l; len -= l; ret += l;
14107
14108ret += Top_tag_oldret;
14109}
14110/* sam-response-prompt */
14111if((data)->sam_response_prompt) {
14112size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14113ret = 0;
14114e = der_put_general_string(p, len, (data)->sam_response_prompt, &l);
14115if (e) return e;
14116p -= l; len -= l; ret += l;
14117
14118e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14119if (e) return e;
14120p -= l; len -= l; ret += l;
14121
14122e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
14123if (e) return e;
14124p -= l; len -= l; ret += l;
14125
14126ret += Top_tag_oldret;
14127}
14128/* sam-challenge */
14129if((data)->sam_challenge) {
14130size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14131ret = 0;
14132e = der_put_general_string(p, len, (data)->sam_challenge, &l);
14133if (e) return e;
14134p -= l; len -= l; ret += l;
14135
14136e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14137if (e) return e;
14138p -= l; len -= l; ret += l;
14139
14140e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
14141if (e) return e;
14142p -= l; len -= l; ret += l;
14143
14144ret += Top_tag_oldret;
14145}
14146/* sam-challenge-label */
14147if((data)->sam_challenge_label) {
14148size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14149ret = 0;
14150e = der_put_general_string(p, len, (data)->sam_challenge_label, &l);
14151if (e) return e;
14152p -= l; len -= l; ret += l;
14153
14154e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14155if (e) return e;
14156p -= l; len -= l; ret += l;
14157
14158e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
14159if (e) return e;
14160p -= l; len -= l; ret += l;
14161
14162ret += Top_tag_oldret;
14163}
14164/* sam-track-id */
14165if((data)->sam_track_id) {
14166size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14167ret = 0;
14168e = der_put_general_string(p, len, (data)->sam_track_id, &l);
14169if (e) return e;
14170p -= l; len -= l; ret += l;
14171
14172e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14173if (e) return e;
14174p -= l; len -= l; ret += l;
14175
14176e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
14177if (e) return e;
14178p -= l; len -= l; ret += l;
14179
14180ret += Top_tag_oldret;
14181}
14182/* sam-type-name */
14183if((data)->sam_type_name) {
14184size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14185ret = 0;
14186e = der_put_general_string(p, len, (data)->sam_type_name, &l);
14187if (e) return e;
14188p -= l; len -= l; ret += l;
14189
14190e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14191if (e) return e;
14192p -= l; len -= l; ret += l;
14193
14194e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
14195if (e) return e;
14196p -= l; len -= l; ret += l;
14197
14198ret += Top_tag_oldret;
14199}
14200/* sam-flags */
14201{
14202size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14203ret = 0;
14204e = encode_SAMFlags(p, len, &(data)->sam_flags, &l);
14205if (e) return e;
14206p -= l; len -= l; ret += l;
14207
14208e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
14209if (e) return e;
14210p -= l; len -= l; ret += l;
14211
14212ret += Top_tag_oldret;
14213}
14214/* sam-type */
14215{
14216size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14217ret = 0;
14218e = encode_krb5int32(p, len, &(data)->sam_type, &l);
14219if (e) return e;
14220p -= l; len -= l; ret += l;
14221
14222e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
14223if (e) return e;
14224p -= l; len -= l; ret += l;
14225
14226ret += Top_tag_oldret;
14227}
14228e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14229if (e) return e;
14230p -= l; len -= l; ret += l;
14231
14232*size = ret;
14233return 0;
14234}
14235
14236int ASN1CALL
14237decode_PA_SAM_CHALLENGE_2_BODY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_CHALLENGE_2_BODY *data, size_t *size)
14238{
14239size_t ret = 0;
14240size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14241int e HEIMDAL_UNUSED_ATTRIBUTE;
14242
14243memset(data, 0, sizeof(*data));
14244{
14245size_t Top_datalen, Top_oldlen;
14246Der_type Top_type;
14247e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
14248if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
14249if(e) goto fail;
14250p += l; len -= l; ret += l;
14251Top_oldlen = len;
14252if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14253len = Top_datalen;
14254{
14255size_t sam_type_datalen, sam_type_oldlen;
14256Der_type sam_type_type;
14257e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_type_type, 0, &sam_type_datalen, &l);
14258if (e == 0 && sam_type_type != CONS) { e = ASN1_BAD_ID; }
14259if(e) goto fail;
14260p += l; len -= l; ret += l;
14261sam_type_oldlen = len;
14262if (sam_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14263len = sam_type_datalen;
14264e = decode_krb5int32(p, len, &(data)->sam_type, &l);
14265if(e) goto fail;
14266p += l; len -= l; ret += l;
14267len = sam_type_oldlen - sam_type_datalen;
14268}
14269{
14270size_t sam_flags_datalen, sam_flags_oldlen;
14271Der_type sam_flags_type;
14272e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_flags_type, 1, &sam_flags_datalen, &l);
14273if (e == 0 && sam_flags_type != CONS) { e = ASN1_BAD_ID; }
14274if(e) goto fail;
14275p += l; len -= l; ret += l;
14276sam_flags_oldlen = len;
14277if (sam_flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14278len = sam_flags_datalen;
14279e = decode_SAMFlags(p, len, &(data)->sam_flags, &l);
14280if(e) goto fail;
14281p += l; len -= l; ret += l;
14282len = sam_flags_oldlen - sam_flags_datalen;
14283}
14284{
14285size_t sam_type_name_datalen, sam_type_name_oldlen;
14286Der_type sam_type_name_type;
14287e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_type_name_type, 2, &sam_type_name_datalen, &l);
14288if (e == 0 && sam_type_name_type != CONS) { e = ASN1_BAD_ID; }
14289if(e) {
14290(data)->sam_type_name = NULL;
14291} else {
14292(data)->sam_type_name = calloc(1, sizeof(*(data)->sam_type_name));
14293if ((data)->sam_type_name == NULL) { e = ENOMEM; goto fail; }
14294p += l; len -= l; ret += l;
14295sam_type_name_oldlen = len;
14296if (sam_type_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14297len = sam_type_name_datalen;
14298{
14299size_t sam_type_name_Tag_datalen, sam_type_name_Tag_oldlen;
14300Der_type sam_type_name_Tag_type;
14301e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_type_name_Tag_type, UT_GeneralString, &sam_type_name_Tag_datalen, &l);
14302if (e == 0 && sam_type_name_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14303if(e) goto fail;
14304p += l; len -= l; ret += l;
14305sam_type_name_Tag_oldlen = len;
14306if (sam_type_name_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14307len = sam_type_name_Tag_datalen;
14308e = der_get_general_string(p, len, (data)->sam_type_name, &l);
14309if(e) goto fail;
14310p += l; len -= l; ret += l;
14311len = sam_type_name_Tag_oldlen - sam_type_name_Tag_datalen;
14312}
14313len = sam_type_name_oldlen - sam_type_name_datalen;
14314}
14315}
14316{
14317size_t sam_track_id_datalen, sam_track_id_oldlen;
14318Der_type sam_track_id_type;
14319e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_track_id_type, 3, &sam_track_id_datalen, &l);
14320if (e == 0 && sam_track_id_type != CONS) { e = ASN1_BAD_ID; }
14321if(e) {
14322(data)->sam_track_id = NULL;
14323} else {
14324(data)->sam_track_id = calloc(1, sizeof(*(data)->sam_track_id));
14325if ((data)->sam_track_id == NULL) { e = ENOMEM; goto fail; }
14326p += l; len -= l; ret += l;
14327sam_track_id_oldlen = len;
14328if (sam_track_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14329len = sam_track_id_datalen;
14330{
14331size_t sam_track_id_Tag_datalen, sam_track_id_Tag_oldlen;
14332Der_type sam_track_id_Tag_type;
14333e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_track_id_Tag_type, UT_GeneralString, &sam_track_id_Tag_datalen, &l);
14334if (e == 0 && sam_track_id_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14335if(e) goto fail;
14336p += l; len -= l; ret += l;
14337sam_track_id_Tag_oldlen = len;
14338if (sam_track_id_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14339len = sam_track_id_Tag_datalen;
14340e = der_get_general_string(p, len, (data)->sam_track_id, &l);
14341if(e) goto fail;
14342p += l; len -= l; ret += l;
14343len = sam_track_id_Tag_oldlen - sam_track_id_Tag_datalen;
14344}
14345len = sam_track_id_oldlen - sam_track_id_datalen;
14346}
14347}
14348{
14349size_t sam_challenge_label_datalen, sam_challenge_label_oldlen;
14350Der_type sam_challenge_label_type;
14351e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_challenge_label_type, 4, &sam_challenge_label_datalen, &l);
14352if (e == 0 && sam_challenge_label_type != CONS) { e = ASN1_BAD_ID; }
14353if(e) {
14354(data)->sam_challenge_label = NULL;
14355} else {
14356(data)->sam_challenge_label = calloc(1, sizeof(*(data)->sam_challenge_label));
14357if ((data)->sam_challenge_label == NULL) { e = ENOMEM; goto fail; }
14358p += l; len -= l; ret += l;
14359sam_challenge_label_oldlen = len;
14360if (sam_challenge_label_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14361len = sam_challenge_label_datalen;
14362{
14363size_t sam_challenge_label_Tag_datalen, sam_challenge_label_Tag_oldlen;
14364Der_type sam_challenge_label_Tag_type;
14365e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_challenge_label_Tag_type, UT_GeneralString, &sam_challenge_label_Tag_datalen, &l);
14366if (e == 0 && sam_challenge_label_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14367if(e) goto fail;
14368p += l; len -= l; ret += l;
14369sam_challenge_label_Tag_oldlen = len;
14370if (sam_challenge_label_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14371len = sam_challenge_label_Tag_datalen;
14372e = der_get_general_string(p, len, (data)->sam_challenge_label, &l);
14373if(e) goto fail;
14374p += l; len -= l; ret += l;
14375len = sam_challenge_label_Tag_oldlen - sam_challenge_label_Tag_datalen;
14376}
14377len = sam_challenge_label_oldlen - sam_challenge_label_datalen;
14378}
14379}
14380{
14381size_t sam_challenge_datalen, sam_challenge_oldlen;
14382Der_type sam_challenge_type;
14383e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_challenge_type, 5, &sam_challenge_datalen, &l);
14384if (e == 0 && sam_challenge_type != CONS) { e = ASN1_BAD_ID; }
14385if(e) {
14386(data)->sam_challenge = NULL;
14387} else {
14388(data)->sam_challenge = calloc(1, sizeof(*(data)->sam_challenge));
14389if ((data)->sam_challenge == NULL) { e = ENOMEM; goto fail; }
14390p += l; len -= l; ret += l;
14391sam_challenge_oldlen = len;
14392if (sam_challenge_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14393len = sam_challenge_datalen;
14394{
14395size_t sam_challenge_Tag_datalen, sam_challenge_Tag_oldlen;
14396Der_type sam_challenge_Tag_type;
14397e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_challenge_Tag_type, UT_GeneralString, &sam_challenge_Tag_datalen, &l);
14398if (e == 0 && sam_challenge_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14399if(e) goto fail;
14400p += l; len -= l; ret += l;
14401sam_challenge_Tag_oldlen = len;
14402if (sam_challenge_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14403len = sam_challenge_Tag_datalen;
14404e = der_get_general_string(p, len, (data)->sam_challenge, &l);
14405if(e) goto fail;
14406p += l; len -= l; ret += l;
14407len = sam_challenge_Tag_oldlen - sam_challenge_Tag_datalen;
14408}
14409len = sam_challenge_oldlen - sam_challenge_datalen;
14410}
14411}
14412{
14413size_t sam_response_prompt_datalen, sam_response_prompt_oldlen;
14414Der_type sam_response_prompt_type;
14415e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_response_prompt_type, 6, &sam_response_prompt_datalen, &l);
14416if (e == 0 && sam_response_prompt_type != CONS) { e = ASN1_BAD_ID; }
14417if(e) {
14418(data)->sam_response_prompt = NULL;
14419} else {
14420(data)->sam_response_prompt = calloc(1, sizeof(*(data)->sam_response_prompt));
14421if ((data)->sam_response_prompt == NULL) { e = ENOMEM; goto fail; }
14422p += l; len -= l; ret += l;
14423sam_response_prompt_oldlen = len;
14424if (sam_response_prompt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14425len = sam_response_prompt_datalen;
14426{
14427size_t sam_response_prompt_Tag_datalen, sam_response_prompt_Tag_oldlen;
14428Der_type sam_response_prompt_Tag_type;
14429e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_response_prompt_Tag_type, UT_GeneralString, &sam_response_prompt_Tag_datalen, &l);
14430if (e == 0 && sam_response_prompt_Tag_type != PRIM) { e = ASN1_BAD_ID; }
14431if(e) goto fail;
14432p += l; len -= l; ret += l;
14433sam_response_prompt_Tag_oldlen = len;
14434if (sam_response_prompt_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14435len = sam_response_prompt_Tag_datalen;
14436e = der_get_general_string(p, len, (data)->sam_response_prompt, &l);
14437if(e) goto fail;
14438p += l; len -= l; ret += l;
14439len = sam_response_prompt_Tag_oldlen - sam_response_prompt_Tag_datalen;
14440}
14441len = sam_response_prompt_oldlen - sam_response_prompt_datalen;
14442}
14443}
14444{
14445size_t sam_pk_for_sad_datalen, sam_pk_for_sad_oldlen;
14446Der_type sam_pk_for_sad_type;
14447e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_pk_for_sad_type, 7, &sam_pk_for_sad_datalen, &l);
14448if (e == 0 && sam_pk_for_sad_type != CONS) { e = ASN1_BAD_ID; }
14449if(e) {
14450(data)->sam_pk_for_sad = NULL;
14451} else {
14452(data)->sam_pk_for_sad = calloc(1, sizeof(*(data)->sam_pk_for_sad));
14453if ((data)->sam_pk_for_sad == NULL) { e = ENOMEM; goto fail; }
14454p += l; len -= l; ret += l;
14455sam_pk_for_sad_oldlen = len;
14456if (sam_pk_for_sad_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14457len = sam_pk_for_sad_datalen;
14458e = decode_EncryptionKey(p, len, (data)->sam_pk_for_sad, &l);
14459if(e) goto fail;
14460p += l; len -= l; ret += l;
14461len = sam_pk_for_sad_oldlen - sam_pk_for_sad_datalen;
14462}
14463}
14464{
14465size_t sam_nonce_datalen, sam_nonce_oldlen;
14466Der_type sam_nonce_type;
14467e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_nonce_type, 8, &sam_nonce_datalen, &l);
14468if (e == 0 && sam_nonce_type != CONS) { e = ASN1_BAD_ID; }
14469if(e) goto fail;
14470p += l; len -= l; ret += l;
14471sam_nonce_oldlen = len;
14472if (sam_nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14473len = sam_nonce_datalen;
14474e = decode_krb5int32(p, len, &(data)->sam_nonce, &l);
14475if(e) goto fail;
14476p += l; len -= l; ret += l;
14477len = sam_nonce_oldlen - sam_nonce_datalen;
14478}
14479{
14480size_t sam_etype_datalen, sam_etype_oldlen;
14481Der_type sam_etype_type;
14482e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_etype_type, 9, &sam_etype_datalen, &l);
14483if (e == 0 && sam_etype_type != CONS) { e = ASN1_BAD_ID; }
14484if(e) goto fail;
14485p += l; len -= l; ret += l;
14486sam_etype_oldlen = len;
14487if (sam_etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14488len = sam_etype_datalen;
14489e = decode_krb5int32(p, len, &(data)->sam_etype, &l);
14490if(e) goto fail;
14491p += l; len -= l; ret += l;
14492len = sam_etype_oldlen - sam_etype_datalen;
14493}
14494len = Top_oldlen - Top_datalen;
14495}
14496if(size) *size = ret;
14497return 0;
14498fail:
14499free_PA_SAM_CHALLENGE_2_BODY(data);
14500return e;
14501}
14502
14503void ASN1CALL
14504free_PA_SAM_CHALLENGE_2_BODY(PA_SAM_CHALLENGE_2_BODY *data)
14505{
14506free_krb5int32(&(data)->sam_type);
14507free_SAMFlags(&(data)->sam_flags);
14508if((data)->sam_type_name) {
14509der_free_general_string((data)->sam_type_name);
14510free((data)->sam_type_name);
14511(data)->sam_type_name = NULL;
14512}
14513if((data)->sam_track_id) {
14514der_free_general_string((data)->sam_track_id);
14515free((data)->sam_track_id);
14516(data)->sam_track_id = NULL;
14517}
14518if((data)->sam_challenge_label) {
14519der_free_general_string((data)->sam_challenge_label);
14520free((data)->sam_challenge_label);
14521(data)->sam_challenge_label = NULL;
14522}
14523if((data)->sam_challenge) {
14524der_free_general_string((data)->sam_challenge);
14525free((data)->sam_challenge);
14526(data)->sam_challenge = NULL;
14527}
14528if((data)->sam_response_prompt) {
14529der_free_general_string((data)->sam_response_prompt);
14530free((data)->sam_response_prompt);
14531(data)->sam_response_prompt = NULL;
14532}
14533if((data)->sam_pk_for_sad) {
14534free_EncryptionKey((data)->sam_pk_for_sad);
14535free((data)->sam_pk_for_sad);
14536(data)->sam_pk_for_sad = NULL;
14537}
14538free_krb5int32(&(data)->sam_nonce);
14539free_krb5int32(&(data)->sam_etype);
14540}
14541
14542size_t ASN1CALL
14543length_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *data)
14544{
14545size_t ret = 0;
14546{
14547size_t Top_tag_oldret = ret;
14548ret = 0;
14549ret += length_krb5int32(&(data)->sam_type);
14550ret += 1 + der_length_len (ret);
14551ret += Top_tag_oldret;
14552}
14553{
14554size_t Top_tag_oldret = ret;
14555ret = 0;
14556ret += length_SAMFlags(&(data)->sam_flags);
14557ret += 1 + der_length_len (ret);
14558ret += Top_tag_oldret;
14559}
14560if((data)->sam_type_name){
14561size_t Top_tag_oldret = ret;
14562ret = 0;
14563ret += der_length_general_string((data)->sam_type_name);
14564ret += 1 + der_length_len (ret);
14565ret += 1 + der_length_len (ret);
14566ret += Top_tag_oldret;
14567}
14568if((data)->sam_track_id){
14569size_t Top_tag_oldret = ret;
14570ret = 0;
14571ret += der_length_general_string((data)->sam_track_id);
14572ret += 1 + der_length_len (ret);
14573ret += 1 + der_length_len (ret);
14574ret += Top_tag_oldret;
14575}
14576if((data)->sam_challenge_label){
14577size_t Top_tag_oldret = ret;
14578ret = 0;
14579ret += der_length_general_string((data)->sam_challenge_label);
14580ret += 1 + der_length_len (ret);
14581ret += 1 + der_length_len (ret);
14582ret += Top_tag_oldret;
14583}
14584if((data)->sam_challenge){
14585size_t Top_tag_oldret = ret;
14586ret = 0;
14587ret += der_length_general_string((data)->sam_challenge);
14588ret += 1 + der_length_len (ret);
14589ret += 1 + der_length_len (ret);
14590ret += Top_tag_oldret;
14591}
14592if((data)->sam_response_prompt){
14593size_t Top_tag_oldret = ret;
14594ret = 0;
14595ret += der_length_general_string((data)->sam_response_prompt);
14596ret += 1 + der_length_len (ret);
14597ret += 1 + der_length_len (ret);
14598ret += Top_tag_oldret;
14599}
14600if((data)->sam_pk_for_sad){
14601size_t Top_tag_oldret = ret;
14602ret = 0;
14603ret += length_EncryptionKey((data)->sam_pk_for_sad);
14604ret += 1 + der_length_len (ret);
14605ret += Top_tag_oldret;
14606}
14607{
14608size_t Top_tag_oldret = ret;
14609ret = 0;
14610ret += length_krb5int32(&(data)->sam_nonce);
14611ret += 1 + der_length_len (ret);
14612ret += Top_tag_oldret;
14613}
14614{
14615size_t Top_tag_oldret = ret;
14616ret = 0;
14617ret += length_krb5int32(&(data)->sam_etype);
14618ret += 1 + der_length_len (ret);
14619ret += Top_tag_oldret;
14620}
14621ret += 1 + der_length_len (ret);
14622return ret;
14623}
14624
14625int ASN1CALL
14626copy_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *from, PA_SAM_CHALLENGE_2_BODY *to)
14627{
14628memset(to, 0, sizeof(*to));
14629if(copy_krb5int32(&(from)->sam_type, &(to)->sam_type)) goto fail;
14630if(copy_SAMFlags(&(from)->sam_flags, &(to)->sam_flags)) goto fail;
14631if((from)->sam_type_name) {
14632(to)->sam_type_name = malloc(sizeof(*(to)->sam_type_name));
14633if((to)->sam_type_name == NULL) goto fail;
14634if(der_copy_general_string((from)->sam_type_name, (to)->sam_type_name)) goto fail;
14635}else
14636(to)->sam_type_name = NULL;
14637if((from)->sam_track_id) {
14638(to)->sam_track_id = malloc(sizeof(*(to)->sam_track_id));
14639if((to)->sam_track_id == NULL) goto fail;
14640if(der_copy_general_string((from)->sam_track_id, (to)->sam_track_id)) goto fail;
14641}else
14642(to)->sam_track_id = NULL;
14643if((from)->sam_challenge_label) {
14644(to)->sam_challenge_label = malloc(sizeof(*(to)->sam_challenge_label));
14645if((to)->sam_challenge_label == NULL) goto fail;
14646if(der_copy_general_string((from)->sam_challenge_label, (to)->sam_challenge_label)) goto fail;
14647}else
14648(to)->sam_challenge_label = NULL;
14649if((from)->sam_challenge) {
14650(to)->sam_challenge = malloc(sizeof(*(to)->sam_challenge));
14651if((to)->sam_challenge == NULL) goto fail;
14652if(der_copy_general_string((from)->sam_challenge, (to)->sam_challenge)) goto fail;
14653}else
14654(to)->sam_challenge = NULL;
14655if((from)->sam_response_prompt) {
14656(to)->sam_response_prompt = malloc(sizeof(*(to)->sam_response_prompt));
14657if((to)->sam_response_prompt == NULL) goto fail;
14658if(der_copy_general_string((from)->sam_response_prompt, (to)->sam_response_prompt)) goto fail;
14659}else
14660(to)->sam_response_prompt = NULL;
14661if((from)->sam_pk_for_sad) {
14662(to)->sam_pk_for_sad = malloc(sizeof(*(to)->sam_pk_for_sad));
14663if((to)->sam_pk_for_sad == NULL) goto fail;
14664if(copy_EncryptionKey((from)->sam_pk_for_sad, (to)->sam_pk_for_sad)) goto fail;
14665}else
14666(to)->sam_pk_for_sad = NULL;
14667if(copy_krb5int32(&(from)->sam_nonce, &(to)->sam_nonce)) goto fail;
14668if(copy_krb5int32(&(from)->sam_etype, &(to)->sam_etype)) goto fail;
14669return 0;
14670fail:
14671free_PA_SAM_CHALLENGE_2_BODY(to);
14672return ENOMEM;
14673}
14674
14675int ASN1CALL
14676encode_PA_SAM_CHALLENGE_2(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_CHALLENGE_2 *data, size_t *size)
14677{
14678size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
14679size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14680int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
14681
14682/* sam-cksum */
14683{
14684size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14685ret = 0;
14686for(i = (int)(&(data)->sam_cksum)->len - 1; i >= 0; --i) {
14687size_t sam_cksum_tag_tag_for_oldret = ret;
14688ret = 0;
14689e = encode_Checksum(p, len, &(&(data)->sam_cksum)->val[i], &l);
14690if (e) return e;
14691p -= l; len -= l; ret += l;
14692
14693ret += sam_cksum_tag_tag_for_oldret;
14694}
14695e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14696if (e) return e;
14697p -= l; len -= l; ret += l;
14698
14699e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
14700if (e) return e;
14701p -= l; len -= l; ret += l;
14702
14703ret += Top_tag_oldret;
14704}
14705/* sam-body */
14706{
14707size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14708ret = 0;
14709e = encode_PA_SAM_CHALLENGE_2_BODY(p, len, &(data)->sam_body, &l);
14710if (e) return e;
14711p -= l; len -= l; ret += l;
14712
14713e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
14714if (e) return e;
14715p -= l; len -= l; ret += l;
14716
14717ret += Top_tag_oldret;
14718}
14719e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14720if (e) return e;
14721p -= l; len -= l; ret += l;
14722
14723*size = ret;
14724return 0;
14725}
14726
14727int ASN1CALL
14728decode_PA_SAM_CHALLENGE_2(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_CHALLENGE_2 *data, size_t *size)
14729{
14730size_t ret = 0;
14731size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14732int e HEIMDAL_UNUSED_ATTRIBUTE;
14733
14734memset(data, 0, sizeof(*data));
14735{
14736size_t Top_datalen, Top_oldlen;
14737Der_type Top_type;
14738e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
14739if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
14740if(e) goto fail;
14741p += l; len -= l; ret += l;
14742Top_oldlen = len;
14743if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14744len = Top_datalen;
14745{
14746size_t sam_body_datalen, sam_body_oldlen;
14747Der_type sam_body_type;
14748e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_body_type, 0, &sam_body_datalen, &l);
14749if (e == 0 && sam_body_type != CONS) { e = ASN1_BAD_ID; }
14750if(e) goto fail;
14751p += l; len -= l; ret += l;
14752sam_body_oldlen = len;
14753if (sam_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14754len = sam_body_datalen;
14755e = decode_PA_SAM_CHALLENGE_2_BODY(p, len, &(data)->sam_body, &l);
14756if(e) goto fail;
14757p += l; len -= l; ret += l;
14758len = sam_body_oldlen - sam_body_datalen;
14759}
14760{
14761size_t sam_cksum_datalen, sam_cksum_oldlen;
14762Der_type sam_cksum_type;
14763e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_cksum_type, 1, &sam_cksum_datalen, &l);
14764if (e == 0 && sam_cksum_type != CONS) { e = ASN1_BAD_ID; }
14765if(e) goto fail;
14766p += l; len -= l; ret += l;
14767sam_cksum_oldlen = len;
14768if (sam_cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14769len = sam_cksum_datalen;
14770{
14771size_t sam_cksum_Tag_datalen, sam_cksum_Tag_oldlen;
14772Der_type sam_cksum_Tag_type;
14773e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_cksum_Tag_type, UT_Sequence, &sam_cksum_Tag_datalen, &l);
14774if (e == 0 && sam_cksum_Tag_type != CONS) { e = ASN1_BAD_ID; }
14775if(e) goto fail;
14776p += l; len -= l; ret += l;
14777sam_cksum_Tag_oldlen = len;
14778if (sam_cksum_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14779len = sam_cksum_Tag_datalen;
14780{
14781size_t sam_cksum_Tag_Tag_origlen = len;
14782size_t sam_cksum_Tag_Tag_oldret = ret;
14783size_t sam_cksum_Tag_Tag_olen = 0;
14784void *sam_cksum_Tag_Tag_tmp;
14785ret = 0;
14786(&(data)->sam_cksum)->len = 0;
14787(&(data)->sam_cksum)->val = NULL;
14788while(ret < sam_cksum_Tag_Tag_origlen) {
14789size_t sam_cksum_Tag_Tag_nlen = sam_cksum_Tag_Tag_olen + sizeof(*((&(data)->sam_cksum)->val));
14790if (sam_cksum_Tag_Tag_olen > sam_cksum_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
14791sam_cksum_Tag_Tag_olen = sam_cksum_Tag_Tag_nlen;
14792sam_cksum_Tag_Tag_tmp = realloc((&(data)->sam_cksum)->val, sam_cksum_Tag_Tag_olen);
14793if (sam_cksum_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
14794(&(data)->sam_cksum)->val = sam_cksum_Tag_Tag_tmp;
14795e = decode_Checksum(p, len, &(&(data)->sam_cksum)->val[(&(data)->sam_cksum)->len], &l);
14796if(e) goto fail;
14797p += l; len -= l; ret += l;
14798(&(data)->sam_cksum)->len++;
14799len = sam_cksum_Tag_Tag_origlen - ret;
14800}
14801ret += sam_cksum_Tag_Tag_oldret;
14802}
14803len = sam_cksum_Tag_oldlen - sam_cksum_Tag_datalen;
14804}
14805len = sam_cksum_oldlen - sam_cksum_datalen;
14806}
14807len = Top_oldlen - Top_datalen;
14808}
14809if(size) *size = ret;
14810return 0;
14811fail:
14812free_PA_SAM_CHALLENGE_2(data);
14813return e;
14814}
14815
14816void ASN1CALL
14817free_PA_SAM_CHALLENGE_2(PA_SAM_CHALLENGE_2 *data)
14818{
14819free_PA_SAM_CHALLENGE_2_BODY(&(data)->sam_body);
14820while((&(data)->sam_cksum)->len){
14821free_Checksum(&(&(data)->sam_cksum)->val[(&(data)->sam_cksum)->len-1]);
14822(&(data)->sam_cksum)->len--;
14823}
14824free((&(data)->sam_cksum)->val);
14825(&(data)->sam_cksum)->val = NULL;
14826}
14827
14828size_t ASN1CALL
14829length_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *data)
14830{
14831size_t ret = 0;
14832{
14833size_t Top_tag_oldret = ret;
14834ret = 0;
14835ret += length_PA_SAM_CHALLENGE_2_BODY(&(data)->sam_body);
14836ret += 1 + der_length_len (ret);
14837ret += Top_tag_oldret;
14838}
14839{
14840size_t Top_tag_oldret = ret;
14841ret = 0;
14842{
14843size_t sam_cksum_tag_tag_oldret = ret;
14844unsigned int n_sam_cksum_tag_tag;
14845ret = 0;
14846for(n_sam_cksum_tag_tag = (&(data)->sam_cksum)->len; n_sam_cksum_tag_tag > 0; --n_sam_cksum_tag_tag){
14847size_t sam_cksum_tag_tag_for_oldret = ret;
14848ret = 0;
14849ret += length_Checksum(&(&(data)->sam_cksum)->val[n_sam_cksum_tag_tag - 1]);
14850ret += sam_cksum_tag_tag_for_oldret;
14851}
14852ret += sam_cksum_tag_tag_oldret;
14853}
14854ret += 1 + der_length_len (ret);
14855ret += 1 + der_length_len (ret);
14856ret += Top_tag_oldret;
14857}
14858ret += 1 + der_length_len (ret);
14859return ret;
14860}
14861
14862int ASN1CALL
14863copy_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *from, PA_SAM_CHALLENGE_2 *to)
14864{
14865memset(to, 0, sizeof(*to));
14866if(copy_PA_SAM_CHALLENGE_2_BODY(&(from)->sam_body, &(to)->sam_body)) goto fail;
14867if(((&(to)->sam_cksum)->val = malloc((&(from)->sam_cksum)->len * sizeof(*(&(to)->sam_cksum)->val))) == NULL && (&(from)->sam_cksum)->len != 0)
14868goto fail;
14869for((&(to)->sam_cksum)->len = 0; (&(to)->sam_cksum)->len < (&(from)->sam_cksum)->len; (&(to)->sam_cksum)->len++){
14870if(copy_Checksum(&(&(from)->sam_cksum)->val[(&(to)->sam_cksum)->len], &(&(to)->sam_cksum)->val[(&(to)->sam_cksum)->len])) goto fail;
14871}
14872return 0;
14873fail:
14874free_PA_SAM_CHALLENGE_2(to);
14875return ENOMEM;
14876}
14877
14878int ASN1CALL
14879encode_PA_SAM_RESPONSE_2(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SAM_RESPONSE_2 *data, size_t *size)
14880{
14881size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
14882size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14883int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
14884
14885/* sam-nonce */
14886{
14887size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14888ret = 0;
14889e = encode_krb5int32(p, len, &(data)->sam_nonce, &l);
14890if (e) return e;
14891p -= l; len -= l; ret += l;
14892
14893e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
14894if (e) return e;
14895p -= l; len -= l; ret += l;
14896
14897ret += Top_tag_oldret;
14898}
14899/* sam-enc-nonce-or-sad */
14900{
14901size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14902ret = 0;
14903e = encode_EncryptedData(p, len, &(data)->sam_enc_nonce_or_sad, &l);
14904if (e) return e;
14905p -= l; len -= l; ret += l;
14906
14907e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
14908if (e) return e;
14909p -= l; len -= l; ret += l;
14910
14911ret += Top_tag_oldret;
14912}
14913/* sam-track-id */
14914if((data)->sam_track_id) {
14915size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14916ret = 0;
14917e = der_put_general_string(p, len, (data)->sam_track_id, &l);
14918if (e) return e;
14919p -= l; len -= l; ret += l;
14920
14921e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
14922if (e) return e;
14923p -= l; len -= l; ret += l;
14924
14925e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
14926if (e) return e;
14927p -= l; len -= l; ret += l;
14928
14929ret += Top_tag_oldret;
14930}
14931/* sam-flags */
14932{
14933size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14934ret = 0;
14935e = encode_SAMFlags(p, len, &(data)->sam_flags, &l);
14936if (e) return e;
14937p -= l; len -= l; ret += l;
14938
14939e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
14940if (e) return e;
14941p -= l; len -= l; ret += l;
14942
14943ret += Top_tag_oldret;
14944}
14945/* sam-type */
14946{
14947size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
14948ret = 0;
14949e = encode_krb5int32(p, len, &(data)->sam_type, &l);
14950if (e) return e;
14951p -= l; len -= l; ret += l;
14952
14953e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
14954if (e) return e;
14955p -= l; len -= l; ret += l;
14956
14957ret += Top_tag_oldret;
14958}
14959e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
14960if (e) return e;
14961p -= l; len -= l; ret += l;
14962
14963*size = ret;
14964return 0;
14965}
14966
14967int ASN1CALL
14968decode_PA_SAM_RESPONSE_2(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SAM_RESPONSE_2 *data, size_t *size)
14969{
14970size_t ret = 0;
14971size_t l HEIMDAL_UNUSED_ATTRIBUTE;
14972int e HEIMDAL_UNUSED_ATTRIBUTE;
14973
14974memset(data, 0, sizeof(*data));
14975{
14976size_t Top_datalen, Top_oldlen;
14977Der_type Top_type;
14978e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
14979if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
14980if(e) goto fail;
14981p += l; len -= l; ret += l;
14982Top_oldlen = len;
14983if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14984len = Top_datalen;
14985{
14986size_t sam_type_datalen, sam_type_oldlen;
14987Der_type sam_type_type;
14988e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_type_type, 0, &sam_type_datalen, &l);
14989if (e == 0 && sam_type_type != CONS) { e = ASN1_BAD_ID; }
14990if(e) goto fail;
14991p += l; len -= l; ret += l;
14992sam_type_oldlen = len;
14993if (sam_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
14994len = sam_type_datalen;
14995e = decode_krb5int32(p, len, &(data)->sam_type, &l);
14996if(e) goto fail;
14997p += l; len -= l; ret += l;
14998len = sam_type_oldlen - sam_type_datalen;
14999}
15000{
15001size_t sam_flags_datalen, sam_flags_oldlen;
15002Der_type sam_flags_type;
15003e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_flags_type, 1, &sam_flags_datalen, &l);
15004if (e == 0 && sam_flags_type != CONS) { e = ASN1_BAD_ID; }
15005if(e) goto fail;
15006p += l; len -= l; ret += l;
15007sam_flags_oldlen = len;
15008if (sam_flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15009len = sam_flags_datalen;
15010e = decode_SAMFlags(p, len, &(data)->sam_flags, &l);
15011if(e) goto fail;
15012p += l; len -= l; ret += l;
15013len = sam_flags_oldlen - sam_flags_datalen;
15014}
15015{
15016size_t sam_track_id_datalen, sam_track_id_oldlen;
15017Der_type sam_track_id_type;
15018e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_track_id_type, 2, &sam_track_id_datalen, &l);
15019if (e == 0 && sam_track_id_type != CONS) { e = ASN1_BAD_ID; }
15020if(e) {
15021(data)->sam_track_id = NULL;
15022} else {
15023(data)->sam_track_id = calloc(1, sizeof(*(data)->sam_track_id));
15024if ((data)->sam_track_id == NULL) { e = ENOMEM; goto fail; }
15025p += l; len -= l; ret += l;
15026sam_track_id_oldlen = len;
15027if (sam_track_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15028len = sam_track_id_datalen;
15029{
15030size_t sam_track_id_Tag_datalen, sam_track_id_Tag_oldlen;
15031Der_type sam_track_id_Tag_type;
15032e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_track_id_Tag_type, UT_GeneralString, &sam_track_id_Tag_datalen, &l);
15033if (e == 0 && sam_track_id_Tag_type != PRIM) { e = ASN1_BAD_ID; }
15034if(e) goto fail;
15035p += l; len -= l; ret += l;
15036sam_track_id_Tag_oldlen = len;
15037if (sam_track_id_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15038len = sam_track_id_Tag_datalen;
15039e = der_get_general_string(p, len, (data)->sam_track_id, &l);
15040if(e) goto fail;
15041p += l; len -= l; ret += l;
15042len = sam_track_id_Tag_oldlen - sam_track_id_Tag_datalen;
15043}
15044len = sam_track_id_oldlen - sam_track_id_datalen;
15045}
15046}
15047{
15048size_t sam_enc_nonce_or_sad_datalen, sam_enc_nonce_or_sad_oldlen;
15049Der_type sam_enc_nonce_or_sad_type;
15050e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_enc_nonce_or_sad_type, 3, &sam_enc_nonce_or_sad_datalen, &l);
15051if (e == 0 && sam_enc_nonce_or_sad_type != CONS) { e = ASN1_BAD_ID; }
15052if(e) goto fail;
15053p += l; len -= l; ret += l;
15054sam_enc_nonce_or_sad_oldlen = len;
15055if (sam_enc_nonce_or_sad_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15056len = sam_enc_nonce_or_sad_datalen;
15057e = decode_EncryptedData(p, len, &(data)->sam_enc_nonce_or_sad, &l);
15058if(e) goto fail;
15059p += l; len -= l; ret += l;
15060len = sam_enc_nonce_or_sad_oldlen - sam_enc_nonce_or_sad_datalen;
15061}
15062{
15063size_t sam_nonce_datalen, sam_nonce_oldlen;
15064Der_type sam_nonce_type;
15065e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_nonce_type, 4, &sam_nonce_datalen, &l);
15066if (e == 0 && sam_nonce_type != CONS) { e = ASN1_BAD_ID; }
15067if(e) goto fail;
15068p += l; len -= l; ret += l;
15069sam_nonce_oldlen = len;
15070if (sam_nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15071len = sam_nonce_datalen;
15072e = decode_krb5int32(p, len, &(data)->sam_nonce, &l);
15073if(e) goto fail;
15074p += l; len -= l; ret += l;
15075len = sam_nonce_oldlen - sam_nonce_datalen;
15076}
15077len = Top_oldlen - Top_datalen;
15078}
15079if(size) *size = ret;
15080return 0;
15081fail:
15082free_PA_SAM_RESPONSE_2(data);
15083return e;
15084}
15085
15086void ASN1CALL
15087free_PA_SAM_RESPONSE_2(PA_SAM_RESPONSE_2 *data)
15088{
15089free_krb5int32(&(data)->sam_type);
15090free_SAMFlags(&(data)->sam_flags);
15091if((data)->sam_track_id) {
15092der_free_general_string((data)->sam_track_id);
15093free((data)->sam_track_id);
15094(data)->sam_track_id = NULL;
15095}
15096free_EncryptedData(&(data)->sam_enc_nonce_or_sad);
15097free_krb5int32(&(data)->sam_nonce);
15098}
15099
15100size_t ASN1CALL
15101length_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *data)
15102{
15103size_t ret = 0;
15104{
15105size_t Top_tag_oldret = ret;
15106ret = 0;
15107ret += length_krb5int32(&(data)->sam_type);
15108ret += 1 + der_length_len (ret);
15109ret += Top_tag_oldret;
15110}
15111{
15112size_t Top_tag_oldret = ret;
15113ret = 0;
15114ret += length_SAMFlags(&(data)->sam_flags);
15115ret += 1 + der_length_len (ret);
15116ret += Top_tag_oldret;
15117}
15118if((data)->sam_track_id){
15119size_t Top_tag_oldret = ret;
15120ret = 0;
15121ret += der_length_general_string((data)->sam_track_id);
15122ret += 1 + der_length_len (ret);
15123ret += 1 + der_length_len (ret);
15124ret += Top_tag_oldret;
15125}
15126{
15127size_t Top_tag_oldret = ret;
15128ret = 0;
15129ret += length_EncryptedData(&(data)->sam_enc_nonce_or_sad);
15130ret += 1 + der_length_len (ret);
15131ret += Top_tag_oldret;
15132}
15133{
15134size_t Top_tag_oldret = ret;
15135ret = 0;
15136ret += length_krb5int32(&(data)->sam_nonce);
15137ret += 1 + der_length_len (ret);
15138ret += Top_tag_oldret;
15139}
15140ret += 1 + der_length_len (ret);
15141return ret;
15142}
15143
15144int ASN1CALL
15145copy_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *from, PA_SAM_RESPONSE_2 *to)
15146{
15147memset(to, 0, sizeof(*to));
15148if(copy_krb5int32(&(from)->sam_type, &(to)->sam_type)) goto fail;
15149if(copy_SAMFlags(&(from)->sam_flags, &(to)->sam_flags)) goto fail;
15150if((from)->sam_track_id) {
15151(to)->sam_track_id = malloc(sizeof(*(to)->sam_track_id));
15152if((to)->sam_track_id == NULL) goto fail;
15153if(der_copy_general_string((from)->sam_track_id, (to)->sam_track_id)) goto fail;
15154}else
15155(to)->sam_track_id = NULL;
15156if(copy_EncryptedData(&(from)->sam_enc_nonce_or_sad, &(to)->sam_enc_nonce_or_sad)) goto fail;
15157if(copy_krb5int32(&(from)->sam_nonce, &(to)->sam_nonce)) goto fail;
15158return 0;
15159fail:
15160free_PA_SAM_RESPONSE_2(to);
15161return ENOMEM;
15162}
15163
15164int ASN1CALL
15165encode_PA_ENC_SAM_RESPONSE_ENC(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_ENC_SAM_RESPONSE_ENC *data, size_t *size)
15166{
15167size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15168size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15169int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15170
15171/* sam-sad */
15172if((data)->sam_sad) {
15173size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15174ret = 0;
15175e = der_put_general_string(p, len, (data)->sam_sad, &l);
15176if (e) return e;
15177p -= l; len -= l; ret += l;
15178
15179e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
15180if (e) return e;
15181p -= l; len -= l; ret += l;
15182
15183e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15184if (e) return e;
15185p -= l; len -= l; ret += l;
15186
15187ret += Top_tag_oldret;
15188}
15189/* sam-nonce */
15190{
15191size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15192ret = 0;
15193e = encode_krb5int32(p, len, &(data)->sam_nonce, &l);
15194if (e) return e;
15195p -= l; len -= l; ret += l;
15196
15197e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15198if (e) return e;
15199p -= l; len -= l; ret += l;
15200
15201ret += Top_tag_oldret;
15202}
15203e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15204if (e) return e;
15205p -= l; len -= l; ret += l;
15206
15207*size = ret;
15208return 0;
15209}
15210
15211int ASN1CALL
15212decode_PA_ENC_SAM_RESPONSE_ENC(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_ENC_SAM_RESPONSE_ENC *data, size_t *size)
15213{
15214size_t ret = 0;
15215size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15216int e HEIMDAL_UNUSED_ATTRIBUTE;
15217
15218memset(data, 0, sizeof(*data));
15219{
15220size_t Top_datalen, Top_oldlen;
15221Der_type Top_type;
15222e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15223if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15224if(e) goto fail;
15225p += l; len -= l; ret += l;
15226Top_oldlen = len;
15227if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15228len = Top_datalen;
15229{
15230size_t sam_nonce_datalen, sam_nonce_oldlen;
15231Der_type sam_nonce_type;
15232e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_nonce_type, 0, &sam_nonce_datalen, &l);
15233if (e == 0 && sam_nonce_type != CONS) { e = ASN1_BAD_ID; }
15234if(e) goto fail;
15235p += l; len -= l; ret += l;
15236sam_nonce_oldlen = len;
15237if (sam_nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15238len = sam_nonce_datalen;
15239e = decode_krb5int32(p, len, &(data)->sam_nonce, &l);
15240if(e) goto fail;
15241p += l; len -= l; ret += l;
15242len = sam_nonce_oldlen - sam_nonce_datalen;
15243}
15244{
15245size_t sam_sad_datalen, sam_sad_oldlen;
15246Der_type sam_sad_type;
15247e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &sam_sad_type, 1, &sam_sad_datalen, &l);
15248if (e == 0 && sam_sad_type != CONS) { e = ASN1_BAD_ID; }
15249if(e) {
15250(data)->sam_sad = NULL;
15251} else {
15252(data)->sam_sad = calloc(1, sizeof(*(data)->sam_sad));
15253if ((data)->sam_sad == NULL) { e = ENOMEM; goto fail; }
15254p += l; len -= l; ret += l;
15255sam_sad_oldlen = len;
15256if (sam_sad_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15257len = sam_sad_datalen;
15258{
15259size_t sam_sad_Tag_datalen, sam_sad_Tag_oldlen;
15260Der_type sam_sad_Tag_type;
15261e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &sam_sad_Tag_type, UT_GeneralString, &sam_sad_Tag_datalen, &l);
15262if (e == 0 && sam_sad_Tag_type != PRIM) { e = ASN1_BAD_ID; }
15263if(e) goto fail;
15264p += l; len -= l; ret += l;
15265sam_sad_Tag_oldlen = len;
15266if (sam_sad_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15267len = sam_sad_Tag_datalen;
15268e = der_get_general_string(p, len, (data)->sam_sad, &l);
15269if(e) goto fail;
15270p += l; len -= l; ret += l;
15271len = sam_sad_Tag_oldlen - sam_sad_Tag_datalen;
15272}
15273len = sam_sad_oldlen - sam_sad_datalen;
15274}
15275}
15276len = Top_oldlen - Top_datalen;
15277}
15278if(size) *size = ret;
15279return 0;
15280fail:
15281free_PA_ENC_SAM_RESPONSE_ENC(data);
15282return e;
15283}
15284
15285void ASN1CALL
15286free_PA_ENC_SAM_RESPONSE_ENC(PA_ENC_SAM_RESPONSE_ENC *data)
15287{
15288free_krb5int32(&(data)->sam_nonce);
15289if((data)->sam_sad) {
15290der_free_general_string((data)->sam_sad);
15291free((data)->sam_sad);
15292(data)->sam_sad = NULL;
15293}
15294}
15295
15296size_t ASN1CALL
15297length_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *data)
15298{
15299size_t ret = 0;
15300{
15301size_t Top_tag_oldret = ret;
15302ret = 0;
15303ret += length_krb5int32(&(data)->sam_nonce);
15304ret += 1 + der_length_len (ret);
15305ret += Top_tag_oldret;
15306}
15307if((data)->sam_sad){
15308size_t Top_tag_oldret = ret;
15309ret = 0;
15310ret += der_length_general_string((data)->sam_sad);
15311ret += 1 + der_length_len (ret);
15312ret += 1 + der_length_len (ret);
15313ret += Top_tag_oldret;
15314}
15315ret += 1 + der_length_len (ret);
15316return ret;
15317}
15318
15319int ASN1CALL
15320copy_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *from, PA_ENC_SAM_RESPONSE_ENC *to)
15321{
15322memset(to, 0, sizeof(*to));
15323if(copy_krb5int32(&(from)->sam_nonce, &(to)->sam_nonce)) goto fail;
15324if((from)->sam_sad) {
15325(to)->sam_sad = malloc(sizeof(*(to)->sam_sad));
15326if((to)->sam_sad == NULL) goto fail;
15327if(der_copy_general_string((from)->sam_sad, (to)->sam_sad)) goto fail;
15328}else
15329(to)->sam_sad = NULL;
15330return 0;
15331fail:
15332free_PA_ENC_SAM_RESPONSE_ENC(to);
15333return ENOMEM;
15334}
15335
15336int ASN1CALL
15337encode_PA_S4U2Self(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_S4U2Self *data, size_t *size)
15338{
15339size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15340size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15341int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15342
15343/* auth */
15344{
15345size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15346ret = 0;
15347e = der_put_general_string(p, len, &(data)->auth, &l);
15348if (e) return e;
15349p -= l; len -= l; ret += l;
15350
15351e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
15352if (e) return e;
15353p -= l; len -= l; ret += l;
15354
15355e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
15356if (e) return e;
15357p -= l; len -= l; ret += l;
15358
15359ret += Top_tag_oldret;
15360}
15361/* cksum */
15362{
15363size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15364ret = 0;
15365e = encode_Checksum(p, len, &(data)->cksum, &l);
15366if (e) return e;
15367p -= l; len -= l; ret += l;
15368
15369e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
15370if (e) return e;
15371p -= l; len -= l; ret += l;
15372
15373ret += Top_tag_oldret;
15374}
15375/* realm */
15376{
15377size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15378ret = 0;
15379e = encode_Realm(p, len, &(data)->realm, &l);
15380if (e) return e;
15381p -= l; len -= l; ret += l;
15382
15383e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15384if (e) return e;
15385p -= l; len -= l; ret += l;
15386
15387ret += Top_tag_oldret;
15388}
15389/* name */
15390{
15391size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15392ret = 0;
15393e = encode_PrincipalName(p, len, &(data)->name, &l);
15394if (e) return e;
15395p -= l; len -= l; ret += l;
15396
15397e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15398if (e) return e;
15399p -= l; len -= l; ret += l;
15400
15401ret += Top_tag_oldret;
15402}
15403e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15404if (e) return e;
15405p -= l; len -= l; ret += l;
15406
15407*size = ret;
15408return 0;
15409}
15410
15411int ASN1CALL
15412decode_PA_S4U2Self(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_S4U2Self *data, size_t *size)
15413{
15414size_t ret = 0;
15415size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15416int e HEIMDAL_UNUSED_ATTRIBUTE;
15417
15418memset(data, 0, sizeof(*data));
15419{
15420size_t Top_datalen, Top_oldlen;
15421Der_type Top_type;
15422e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15423if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15424if(e) goto fail;
15425p += l; len -= l; ret += l;
15426Top_oldlen = len;
15427if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15428len = Top_datalen;
15429{
15430size_t name_datalen, name_oldlen;
15431Der_type name_type;
15432e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type, 0, &name_datalen, &l);
15433if (e == 0 && name_type != CONS) { e = ASN1_BAD_ID; }
15434if(e) goto fail;
15435p += l; len -= l; ret += l;
15436name_oldlen = len;
15437if (name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15438len = name_datalen;
15439e = decode_PrincipalName(p, len, &(data)->name, &l);
15440if(e) goto fail;
15441p += l; len -= l; ret += l;
15442len = name_oldlen - name_datalen;
15443}
15444{
15445size_t realm_datalen, realm_oldlen;
15446Der_type realm_type;
15447e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type, 1, &realm_datalen, &l);
15448if (e == 0 && realm_type != CONS) { e = ASN1_BAD_ID; }
15449if(e) goto fail;
15450p += l; len -= l; ret += l;
15451realm_oldlen = len;
15452if (realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15453len = realm_datalen;
15454e = decode_Realm(p, len, &(data)->realm, &l);
15455if(e) goto fail;
15456p += l; len -= l; ret += l;
15457len = realm_oldlen - realm_datalen;
15458}
15459{
15460size_t cksum_datalen, cksum_oldlen;
15461Der_type cksum_type;
15462e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 2, &cksum_datalen, &l);
15463if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
15464if(e) goto fail;
15465p += l; len -= l; ret += l;
15466cksum_oldlen = len;
15467if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15468len = cksum_datalen;
15469e = decode_Checksum(p, len, &(data)->cksum, &l);
15470if(e) goto fail;
15471p += l; len -= l; ret += l;
15472len = cksum_oldlen - cksum_datalen;
15473}
15474{
15475size_t auth_datalen, auth_oldlen;
15476Der_type auth_type;
15477e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &auth_type, 3, &auth_datalen, &l);
15478if (e == 0 && auth_type != CONS) { e = ASN1_BAD_ID; }
15479if(e) goto fail;
15480p += l; len -= l; ret += l;
15481auth_oldlen = len;
15482if (auth_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15483len = auth_datalen;
15484{
15485size_t auth_Tag_datalen, auth_Tag_oldlen;
15486Der_type auth_Tag_type;
15487e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &auth_Tag_type, UT_GeneralString, &auth_Tag_datalen, &l);
15488if (e == 0 && auth_Tag_type != PRIM) { e = ASN1_BAD_ID; }
15489if(e) goto fail;
15490p += l; len -= l; ret += l;
15491auth_Tag_oldlen = len;
15492if (auth_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15493len = auth_Tag_datalen;
15494e = der_get_general_string(p, len, &(data)->auth, &l);
15495if(e) goto fail;
15496p += l; len -= l; ret += l;
15497len = auth_Tag_oldlen - auth_Tag_datalen;
15498}
15499len = auth_oldlen - auth_datalen;
15500}
15501len = Top_oldlen - Top_datalen;
15502}
15503if(size) *size = ret;
15504return 0;
15505fail:
15506free_PA_S4U2Self(data);
15507return e;
15508}
15509
15510void ASN1CALL
15511free_PA_S4U2Self(PA_S4U2Self *data)
15512{
15513free_PrincipalName(&(data)->name);
15514free_Realm(&(data)->realm);
15515free_Checksum(&(data)->cksum);
15516der_free_general_string(&(data)->auth);
15517}
15518
15519size_t ASN1CALL
15520length_PA_S4U2Self(const PA_S4U2Self *data)
15521{
15522size_t ret = 0;
15523{
15524size_t Top_tag_oldret = ret;
15525ret = 0;
15526ret += length_PrincipalName(&(data)->name);
15527ret += 1 + der_length_len (ret);
15528ret += Top_tag_oldret;
15529}
15530{
15531size_t Top_tag_oldret = ret;
15532ret = 0;
15533ret += length_Realm(&(data)->realm);
15534ret += 1 + der_length_len (ret);
15535ret += Top_tag_oldret;
15536}
15537{
15538size_t Top_tag_oldret = ret;
15539ret = 0;
15540ret += length_Checksum(&(data)->cksum);
15541ret += 1 + der_length_len (ret);
15542ret += Top_tag_oldret;
15543}
15544{
15545size_t Top_tag_oldret = ret;
15546ret = 0;
15547ret += der_length_general_string(&(data)->auth);
15548ret += 1 + der_length_len (ret);
15549ret += 1 + der_length_len (ret);
15550ret += Top_tag_oldret;
15551}
15552ret += 1 + der_length_len (ret);
15553return ret;
15554}
15555
15556int ASN1CALL
15557copy_PA_S4U2Self(const PA_S4U2Self *from, PA_S4U2Self *to)
15558{
15559memset(to, 0, sizeof(*to));
15560if(copy_PrincipalName(&(from)->name, &(to)->name)) goto fail;
15561if(copy_Realm(&(from)->realm, &(to)->realm)) goto fail;
15562if(copy_Checksum(&(from)->cksum, &(to)->cksum)) goto fail;
15563if(der_copy_general_string(&(from)->auth, &(to)->auth)) goto fail;
15564return 0;
15565fail:
15566free_PA_S4U2Self(to);
15567return ENOMEM;
15568}
15569
15570int ASN1CALL
15571encode_KRB5SignedPathData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB5SignedPathData *data, size_t *size)
15572{
15573size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15574size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15575int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15576
15577/* method_data */
15578if((data)->method_data) {
15579size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15580ret = 0;
15581e = encode_METHOD_DATA(p, len, (data)->method_data, &l);
15582if (e) return e;
15583p -= l; len -= l; ret += l;
15584
15585e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
15586if (e) return e;
15587p -= l; len -= l; ret += l;
15588
15589ret += Top_tag_oldret;
15590}
15591/* delegated */
15592if((data)->delegated) {
15593size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15594ret = 0;
15595e = encode_Principals(p, len, (data)->delegated, &l);
15596if (e) return e;
15597p -= l; len -= l; ret += l;
15598
15599e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
15600if (e) return e;
15601p -= l; len -= l; ret += l;
15602
15603ret += Top_tag_oldret;
15604}
15605/* authtime */
15606{
15607size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15608ret = 0;
15609e = encode_KerberosTime(p, len, &(data)->authtime, &l);
15610if (e) return e;
15611p -= l; len -= l; ret += l;
15612
15613e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15614if (e) return e;
15615p -= l; len -= l; ret += l;
15616
15617ret += Top_tag_oldret;
15618}
15619/* client */
15620if((data)->client) {
15621size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15622ret = 0;
15623e = encode_Principal(p, len, (data)->client, &l);
15624if (e) return e;
15625p -= l; len -= l; ret += l;
15626
15627e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15628if (e) return e;
15629p -= l; len -= l; ret += l;
15630
15631ret += Top_tag_oldret;
15632}
15633e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15634if (e) return e;
15635p -= l; len -= l; ret += l;
15636
15637*size = ret;
15638return 0;
15639}
15640
15641int ASN1CALL
15642decode_KRB5SignedPathData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB5SignedPathData *data, size_t *size)
15643{
15644size_t ret = 0;
15645size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15646int e HEIMDAL_UNUSED_ATTRIBUTE;
15647
15648memset(data, 0, sizeof(*data));
15649{
15650size_t Top_datalen, Top_oldlen;
15651Der_type Top_type;
15652e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15653if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15654if(e) goto fail;
15655p += l; len -= l; ret += l;
15656Top_oldlen = len;
15657if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15658len = Top_datalen;
15659{
15660size_t client_datalen, client_oldlen;
15661Der_type client_type;
15662e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &client_type, 0, &client_datalen, &l);
15663if (e == 0 && client_type != CONS) { e = ASN1_BAD_ID; }
15664if(e) {
15665(data)->client = NULL;
15666} else {
15667(data)->client = calloc(1, sizeof(*(data)->client));
15668if ((data)->client == NULL) { e = ENOMEM; goto fail; }
15669p += l; len -= l; ret += l;
15670client_oldlen = len;
15671if (client_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15672len = client_datalen;
15673e = decode_Principal(p, len, (data)->client, &l);
15674if(e) goto fail;
15675p += l; len -= l; ret += l;
15676len = client_oldlen - client_datalen;
15677}
15678}
15679{
15680size_t authtime_datalen, authtime_oldlen;
15681Der_type authtime_type;
15682e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 1, &authtime_datalen, &l);
15683if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
15684if(e) goto fail;
15685p += l; len -= l; ret += l;
15686authtime_oldlen = len;
15687if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15688len = authtime_datalen;
15689e = decode_KerberosTime(p, len, &(data)->authtime, &l);
15690if(e) goto fail;
15691p += l; len -= l; ret += l;
15692len = authtime_oldlen - authtime_datalen;
15693}
15694{
15695size_t delegated_datalen, delegated_oldlen;
15696Der_type delegated_type;
15697e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &delegated_type, 2, &delegated_datalen, &l);
15698if (e == 0 && delegated_type != CONS) { e = ASN1_BAD_ID; }
15699if(e) {
15700(data)->delegated = NULL;
15701} else {
15702(data)->delegated = calloc(1, sizeof(*(data)->delegated));
15703if ((data)->delegated == NULL) { e = ENOMEM; goto fail; }
15704p += l; len -= l; ret += l;
15705delegated_oldlen = len;
15706if (delegated_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15707len = delegated_datalen;
15708e = decode_Principals(p, len, (data)->delegated, &l);
15709if(e) goto fail;
15710p += l; len -= l; ret += l;
15711len = delegated_oldlen - delegated_datalen;
15712}
15713}
15714{
15715size_t method_data_datalen, method_data_oldlen;
15716Der_type method_data_type;
15717e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &method_data_type, 3, &method_data_datalen, &l);
15718if (e == 0 && method_data_type != CONS) { e = ASN1_BAD_ID; }
15719if(e) {
15720(data)->method_data = NULL;
15721} else {
15722(data)->method_data = calloc(1, sizeof(*(data)->method_data));
15723if ((data)->method_data == NULL) { e = ENOMEM; goto fail; }
15724p += l; len -= l; ret += l;
15725method_data_oldlen = len;
15726if (method_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15727len = method_data_datalen;
15728e = decode_METHOD_DATA(p, len, (data)->method_data, &l);
15729if(e) goto fail;
15730p += l; len -= l; ret += l;
15731len = method_data_oldlen - method_data_datalen;
15732}
15733}
15734len = Top_oldlen - Top_datalen;
15735}
15736if(size) *size = ret;
15737return 0;
15738fail:
15739free_KRB5SignedPathData(data);
15740return e;
15741}
15742
15743void ASN1CALL
15744free_KRB5SignedPathData(KRB5SignedPathData *data)
15745{
15746if((data)->client) {
15747free_Principal((data)->client);
15748free((data)->client);
15749(data)->client = NULL;
15750}
15751free_KerberosTime(&(data)->authtime);
15752if((data)->delegated) {
15753free_Principals((data)->delegated);
15754free((data)->delegated);
15755(data)->delegated = NULL;
15756}
15757if((data)->method_data) {
15758free_METHOD_DATA((data)->method_data);
15759free((data)->method_data);
15760(data)->method_data = NULL;
15761}
15762}
15763
15764size_t ASN1CALL
15765length_KRB5SignedPathData(const KRB5SignedPathData *data)
15766{
15767size_t ret = 0;
15768if((data)->client){
15769size_t Top_tag_oldret = ret;
15770ret = 0;
15771ret += length_Principal((data)->client);
15772ret += 1 + der_length_len (ret);
15773ret += Top_tag_oldret;
15774}
15775{
15776size_t Top_tag_oldret = ret;
15777ret = 0;
15778ret += length_KerberosTime(&(data)->authtime);
15779ret += 1 + der_length_len (ret);
15780ret += Top_tag_oldret;
15781}
15782if((data)->delegated){
15783size_t Top_tag_oldret = ret;
15784ret = 0;
15785ret += length_Principals((data)->delegated);
15786ret += 1 + der_length_len (ret);
15787ret += Top_tag_oldret;
15788}
15789if((data)->method_data){
15790size_t Top_tag_oldret = ret;
15791ret = 0;
15792ret += length_METHOD_DATA((data)->method_data);
15793ret += 1 + der_length_len (ret);
15794ret += Top_tag_oldret;
15795}
15796ret += 1 + der_length_len (ret);
15797return ret;
15798}
15799
15800int ASN1CALL
15801copy_KRB5SignedPathData(const KRB5SignedPathData *from, KRB5SignedPathData *to)
15802{
15803memset(to, 0, sizeof(*to));
15804if((from)->client) {
15805(to)->client = malloc(sizeof(*(to)->client));
15806if((to)->client == NULL) goto fail;
15807if(copy_Principal((from)->client, (to)->client)) goto fail;
15808}else
15809(to)->client = NULL;
15810if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) goto fail;
15811if((from)->delegated) {
15812(to)->delegated = malloc(sizeof(*(to)->delegated));
15813if((to)->delegated == NULL) goto fail;
15814if(copy_Principals((from)->delegated, (to)->delegated)) goto fail;
15815}else
15816(to)->delegated = NULL;
15817if((from)->method_data) {
15818(to)->method_data = malloc(sizeof(*(to)->method_data));
15819if((to)->method_data == NULL) goto fail;
15820if(copy_METHOD_DATA((from)->method_data, (to)->method_data)) goto fail;
15821}else
15822(to)->method_data = NULL;
15823return 0;
15824fail:
15825free_KRB5SignedPathData(to);
15826return ENOMEM;
15827}
15828
15829int ASN1CALL
15830encode_KRB5SignedPath(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KRB5SignedPath *data, size_t *size)
15831{
15832size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
15833size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15834int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
15835
15836/* method_data */
15837if((data)->method_data) {
15838size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15839ret = 0;
15840e = encode_METHOD_DATA(p, len, (data)->method_data, &l);
15841if (e) return e;
15842p -= l; len -= l; ret += l;
15843
15844e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
15845if (e) return e;
15846p -= l; len -= l; ret += l;
15847
15848ret += Top_tag_oldret;
15849}
15850/* delegated */
15851if((data)->delegated) {
15852size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15853ret = 0;
15854e = encode_Principals(p, len, (data)->delegated, &l);
15855if (e) return e;
15856p -= l; len -= l; ret += l;
15857
15858e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
15859if (e) return e;
15860p -= l; len -= l; ret += l;
15861
15862ret += Top_tag_oldret;
15863}
15864/* cksum */
15865{
15866size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15867ret = 0;
15868e = encode_Checksum(p, len, &(data)->cksum, &l);
15869if (e) return e;
15870p -= l; len -= l; ret += l;
15871
15872e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
15873if (e) return e;
15874p -= l; len -= l; ret += l;
15875
15876ret += Top_tag_oldret;
15877}
15878/* etype */
15879{
15880size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
15881ret = 0;
15882e = encode_ENCTYPE(p, len, &(data)->etype, &l);
15883if (e) return e;
15884p -= l; len -= l; ret += l;
15885
15886e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
15887if (e) return e;
15888p -= l; len -= l; ret += l;
15889
15890ret += Top_tag_oldret;
15891}
15892e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
15893if (e) return e;
15894p -= l; len -= l; ret += l;
15895
15896*size = ret;
15897return 0;
15898}
15899
15900int ASN1CALL
15901decode_KRB5SignedPath(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KRB5SignedPath *data, size_t *size)
15902{
15903size_t ret = 0;
15904size_t l HEIMDAL_UNUSED_ATTRIBUTE;
15905int e HEIMDAL_UNUSED_ATTRIBUTE;
15906
15907memset(data, 0, sizeof(*data));
15908{
15909size_t Top_datalen, Top_oldlen;
15910Der_type Top_type;
15911e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
15912if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
15913if(e) goto fail;
15914p += l; len -= l; ret += l;
15915Top_oldlen = len;
15916if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15917len = Top_datalen;
15918{
15919size_t etype_datalen, etype_oldlen;
15920Der_type etype_type;
15921e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &etype_type, 0, &etype_datalen, &l);
15922if (e == 0 && etype_type != CONS) { e = ASN1_BAD_ID; }
15923if(e) goto fail;
15924p += l; len -= l; ret += l;
15925etype_oldlen = len;
15926if (etype_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15927len = etype_datalen;
15928e = decode_ENCTYPE(p, len, &(data)->etype, &l);
15929if(e) goto fail;
15930p += l; len -= l; ret += l;
15931len = etype_oldlen - etype_datalen;
15932}
15933{
15934size_t cksum_datalen, cksum_oldlen;
15935Der_type cksum_type;
15936e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cksum_type, 1, &cksum_datalen, &l);
15937if (e == 0 && cksum_type != CONS) { e = ASN1_BAD_ID; }
15938if(e) goto fail;
15939p += l; len -= l; ret += l;
15940cksum_oldlen = len;
15941if (cksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15942len = cksum_datalen;
15943e = decode_Checksum(p, len, &(data)->cksum, &l);
15944if(e) goto fail;
15945p += l; len -= l; ret += l;
15946len = cksum_oldlen - cksum_datalen;
15947}
15948{
15949size_t delegated_datalen, delegated_oldlen;
15950Der_type delegated_type;
15951e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &delegated_type, 2, &delegated_datalen, &l);
15952if (e == 0 && delegated_type != CONS) { e = ASN1_BAD_ID; }
15953if(e) {
15954(data)->delegated = NULL;
15955} else {
15956(data)->delegated = calloc(1, sizeof(*(data)->delegated));
15957if ((data)->delegated == NULL) { e = ENOMEM; goto fail; }
15958p += l; len -= l; ret += l;
15959delegated_oldlen = len;
15960if (delegated_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15961len = delegated_datalen;
15962e = decode_Principals(p, len, (data)->delegated, &l);
15963if(e) goto fail;
15964p += l; len -= l; ret += l;
15965len = delegated_oldlen - delegated_datalen;
15966}
15967}
15968{
15969size_t method_data_datalen, method_data_oldlen;
15970Der_type method_data_type;
15971e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &method_data_type, 3, &method_data_datalen, &l);
15972if (e == 0 && method_data_type != CONS) { e = ASN1_BAD_ID; }
15973if(e) {
15974(data)->method_data = NULL;
15975} else {
15976(data)->method_data = calloc(1, sizeof(*(data)->method_data));
15977if ((data)->method_data == NULL) { e = ENOMEM; goto fail; }
15978p += l; len -= l; ret += l;
15979method_data_oldlen = len;
15980if (method_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
15981len = method_data_datalen;
15982e = decode_METHOD_DATA(p, len, (data)->method_data, &l);
15983if(e) goto fail;
15984p += l; len -= l; ret += l;
15985len = method_data_oldlen - method_data_datalen;
15986}
15987}
15988len = Top_oldlen - Top_datalen;
15989}
15990if(size) *size = ret;
15991return 0;
15992fail:
15993free_KRB5SignedPath(data);
15994return e;
15995}
15996
15997void ASN1CALL
15998free_KRB5SignedPath(KRB5SignedPath *data)
15999{
16000free_ENCTYPE(&(data)->etype);
16001free_Checksum(&(data)->cksum);
16002if((data)->delegated) {
16003free_Principals((data)->delegated);
16004free((data)->delegated);
16005(data)->delegated = NULL;
16006}
16007if((data)->method_data) {
16008free_METHOD_DATA((data)->method_data);
16009free((data)->method_data);
16010(data)->method_data = NULL;
16011}
16012}
16013
16014size_t ASN1CALL
16015length_KRB5SignedPath(const KRB5SignedPath *data)
16016{
16017size_t ret = 0;
16018{
16019size_t Top_tag_oldret = ret;
16020ret = 0;
16021ret += length_ENCTYPE(&(data)->etype);
16022ret += 1 + der_length_len (ret);
16023ret += Top_tag_oldret;
16024}
16025{
16026size_t Top_tag_oldret = ret;
16027ret = 0;
16028ret += length_Checksum(&(data)->cksum);
16029ret += 1 + der_length_len (ret);
16030ret += Top_tag_oldret;
16031}
16032if((data)->delegated){
16033size_t Top_tag_oldret = ret;
16034ret = 0;
16035ret += length_Principals((data)->delegated);
16036ret += 1 + der_length_len (ret);
16037ret += Top_tag_oldret;
16038}
16039if((data)->method_data){
16040size_t Top_tag_oldret = ret;
16041ret = 0;
16042ret += length_METHOD_DATA((data)->method_data);
16043ret += 1 + der_length_len (ret);
16044ret += Top_tag_oldret;
16045}
16046ret += 1 + der_length_len (ret);
16047return ret;
16048}
16049
16050int ASN1CALL
16051copy_KRB5SignedPath(const KRB5SignedPath *from, KRB5SignedPath *to)
16052{
16053memset(to, 0, sizeof(*to));
16054if(copy_ENCTYPE(&(from)->etype, &(to)->etype)) goto fail;
16055if(copy_Checksum(&(from)->cksum, &(to)->cksum)) goto fail;
16056if((from)->delegated) {
16057(to)->delegated = malloc(sizeof(*(to)->delegated));
16058if((to)->delegated == NULL) goto fail;
16059if(copy_Principals((from)->delegated, (to)->delegated)) goto fail;
16060}else
16061(to)->delegated = NULL;
16062if((from)->method_data) {
16063(to)->method_data = malloc(sizeof(*(to)->method_data));
16064if((to)->method_data == NULL) goto fail;
16065if(copy_METHOD_DATA((from)->method_data, (to)->method_data)) goto fail;
16066}else
16067(to)->method_data = NULL;
16068return 0;
16069fail:
16070free_KRB5SignedPath(to);
16071return ENOMEM;
16072}
16073
16074int ASN1CALL
16075encode_AD_LoginAlias(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AD_LoginAlias *data, size_t *size)
16076{
16077size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16078size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16079int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16080
16081/* checksum */
16082{
16083size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16084ret = 0;
16085e = encode_Checksum(p, len, &(data)->checksum, &l);
16086if (e) return e;
16087p -= l; len -= l; ret += l;
16088
16089e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16090if (e) return e;
16091p -= l; len -= l; ret += l;
16092
16093ret += Top_tag_oldret;
16094}
16095/* login-alias */
16096{
16097size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16098ret = 0;
16099e = encode_PrincipalName(p, len, &(data)->login_alias, &l);
16100if (e) return e;
16101p -= l; len -= l; ret += l;
16102
16103e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16104if (e) return e;
16105p -= l; len -= l; ret += l;
16106
16107ret += Top_tag_oldret;
16108}
16109e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16110if (e) return e;
16111p -= l; len -= l; ret += l;
16112
16113*size = ret;
16114return 0;
16115}
16116
16117int ASN1CALL
16118decode_AD_LoginAlias(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AD_LoginAlias *data, size_t *size)
16119{
16120size_t ret = 0;
16121size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16122int e HEIMDAL_UNUSED_ATTRIBUTE;
16123
16124memset(data, 0, sizeof(*data));
16125{
16126size_t Top_datalen, Top_oldlen;
16127Der_type Top_type;
16128e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16129if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16130if(e) goto fail;
16131p += l; len -= l; ret += l;
16132Top_oldlen = len;
16133if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16134len = Top_datalen;
16135{
16136size_t login_alias_datalen, login_alias_oldlen;
16137Der_type login_alias_type;
16138e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &login_alias_type, 0, &login_alias_datalen, &l);
16139if (e == 0 && login_alias_type != CONS) { e = ASN1_BAD_ID; }
16140if(e) goto fail;
16141p += l; len -= l; ret += l;
16142login_alias_oldlen = len;
16143if (login_alias_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16144len = login_alias_datalen;
16145e = decode_PrincipalName(p, len, &(data)->login_alias, &l);
16146if(e) goto fail;
16147p += l; len -= l; ret += l;
16148len = login_alias_oldlen - login_alias_datalen;
16149}
16150{
16151size_t checksum_datalen, checksum_oldlen;
16152Der_type checksum_type;
16153e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &checksum_type, 1, &checksum_datalen, &l);
16154if (e == 0 && checksum_type != CONS) { e = ASN1_BAD_ID; }
16155if(e) goto fail;
16156p += l; len -= l; ret += l;
16157checksum_oldlen = len;
16158if (checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16159len = checksum_datalen;
16160e = decode_Checksum(p, len, &(data)->checksum, &l);
16161if(e) goto fail;
16162p += l; len -= l; ret += l;
16163len = checksum_oldlen - checksum_datalen;
16164}
16165len = Top_oldlen - Top_datalen;
16166}
16167if(size) *size = ret;
16168return 0;
16169fail:
16170free_AD_LoginAlias(data);
16171return e;
16172}
16173
16174void ASN1CALL
16175free_AD_LoginAlias(AD_LoginAlias *data)
16176{
16177free_PrincipalName(&(data)->login_alias);
16178free_Checksum(&(data)->checksum);
16179}
16180
16181size_t ASN1CALL
16182length_AD_LoginAlias(const AD_LoginAlias *data)
16183{
16184size_t ret = 0;
16185{
16186size_t Top_tag_oldret = ret;
16187ret = 0;
16188ret += length_PrincipalName(&(data)->login_alias);
16189ret += 1 + der_length_len (ret);
16190ret += Top_tag_oldret;
16191}
16192{
16193size_t Top_tag_oldret = ret;
16194ret = 0;
16195ret += length_Checksum(&(data)->checksum);
16196ret += 1 + der_length_len (ret);
16197ret += Top_tag_oldret;
16198}
16199ret += 1 + der_length_len (ret);
16200return ret;
16201}
16202
16203int ASN1CALL
16204copy_AD_LoginAlias(const AD_LoginAlias *from, AD_LoginAlias *to)
16205{
16206memset(to, 0, sizeof(*to));
16207if(copy_PrincipalName(&(from)->login_alias, &(to)->login_alias)) goto fail;
16208if(copy_Checksum(&(from)->checksum, &(to)->checksum)) goto fail;
16209return 0;
16210fail:
16211free_AD_LoginAlias(to);
16212return ENOMEM;
16213}
16214
16215int ASN1CALL
16216encode_PA_SvrReferralData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SvrReferralData *data, size_t *size)
16217{
16218size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16219size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16220int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16221
16222/* referred-realm */
16223{
16224size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16225ret = 0;
16226e = encode_Realm(p, len, &(data)->referred_realm, &l);
16227if (e) return e;
16228p -= l; len -= l; ret += l;
16229
16230e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16231if (e) return e;
16232p -= l; len -= l; ret += l;
16233
16234ret += Top_tag_oldret;
16235}
16236/* referred-name */
16237if((data)->referred_name) {
16238size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16239ret = 0;
16240e = encode_PrincipalName(p, len, (data)->referred_name, &l);
16241if (e) return e;
16242p -= l; len -= l; ret += l;
16243
16244e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16245if (e) return e;
16246p -= l; len -= l; ret += l;
16247
16248ret += Top_tag_oldret;
16249}
16250e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16251if (e) return e;
16252p -= l; len -= l; ret += l;
16253
16254*size = ret;
16255return 0;
16256}
16257
16258int ASN1CALL
16259decode_PA_SvrReferralData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SvrReferralData *data, size_t *size)
16260{
16261size_t ret = 0;
16262size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16263int e HEIMDAL_UNUSED_ATTRIBUTE;
16264
16265memset(data, 0, sizeof(*data));
16266{
16267size_t Top_datalen, Top_oldlen;
16268Der_type Top_type;
16269e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16270if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16271if(e) goto fail;
16272p += l; len -= l; ret += l;
16273Top_oldlen = len;
16274if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16275len = Top_datalen;
16276{
16277size_t referred_name_datalen, referred_name_oldlen;
16278Der_type referred_name_type;
16279e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referred_name_type, 1, &referred_name_datalen, &l);
16280if (e == 0 && referred_name_type != CONS) { e = ASN1_BAD_ID; }
16281if(e) {
16282(data)->referred_name = NULL;
16283} else {
16284(data)->referred_name = calloc(1, sizeof(*(data)->referred_name));
16285if ((data)->referred_name == NULL) { e = ENOMEM; goto fail; }
16286p += l; len -= l; ret += l;
16287referred_name_oldlen = len;
16288if (referred_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16289len = referred_name_datalen;
16290e = decode_PrincipalName(p, len, (data)->referred_name, &l);
16291if(e) goto fail;
16292p += l; len -= l; ret += l;
16293len = referred_name_oldlen - referred_name_datalen;
16294}
16295}
16296{
16297size_t referred_realm_datalen, referred_realm_oldlen;
16298Der_type referred_realm_type;
16299e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referred_realm_type, 0, &referred_realm_datalen, &l);
16300if (e == 0 && referred_realm_type != CONS) { e = ASN1_BAD_ID; }
16301if(e) goto fail;
16302p += l; len -= l; ret += l;
16303referred_realm_oldlen = len;
16304if (referred_realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16305len = referred_realm_datalen;
16306e = decode_Realm(p, len, &(data)->referred_realm, &l);
16307if(e) goto fail;
16308p += l; len -= l; ret += l;
16309len = referred_realm_oldlen - referred_realm_datalen;
16310}
16311len = Top_oldlen - Top_datalen;
16312}
16313if(size) *size = ret;
16314return 0;
16315fail:
16316free_PA_SvrReferralData(data);
16317return e;
16318}
16319
16320void ASN1CALL
16321free_PA_SvrReferralData(PA_SvrReferralData *data)
16322{
16323if((data)->referred_name) {
16324free_PrincipalName((data)->referred_name);
16325free((data)->referred_name);
16326(data)->referred_name = NULL;
16327}
16328free_Realm(&(data)->referred_realm);
16329}
16330
16331size_t ASN1CALL
16332length_PA_SvrReferralData(const PA_SvrReferralData *data)
16333{
16334size_t ret = 0;
16335if((data)->referred_name){
16336size_t Top_tag_oldret = ret;
16337ret = 0;
16338ret += length_PrincipalName((data)->referred_name);
16339ret += 1 + der_length_len (ret);
16340ret += Top_tag_oldret;
16341}
16342{
16343size_t Top_tag_oldret = ret;
16344ret = 0;
16345ret += length_Realm(&(data)->referred_realm);
16346ret += 1 + der_length_len (ret);
16347ret += Top_tag_oldret;
16348}
16349ret += 1 + der_length_len (ret);
16350return ret;
16351}
16352
16353int ASN1CALL
16354copy_PA_SvrReferralData(const PA_SvrReferralData *from, PA_SvrReferralData *to)
16355{
16356memset(to, 0, sizeof(*to));
16357if((from)->referred_name) {
16358(to)->referred_name = malloc(sizeof(*(to)->referred_name));
16359if((to)->referred_name == NULL) goto fail;
16360if(copy_PrincipalName((from)->referred_name, (to)->referred_name)) goto fail;
16361}else
16362(to)->referred_name = NULL;
16363if(copy_Realm(&(from)->referred_realm, &(to)->referred_realm)) goto fail;
16364return 0;
16365fail:
16366free_PA_SvrReferralData(to);
16367return ENOMEM;
16368}
16369
16370int ASN1CALL
16371encode_PA_SERVER_REFERRAL_DATA(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_SERVER_REFERRAL_DATA *data, size_t *size)
16372{
16373size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16374size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16375int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16376
16377e = encode_EncryptedData(p, len, data, &l);
16378if (e) return e;
16379p -= l; len -= l; ret += l;
16380
16381*size = ret;
16382return 0;
16383}
16384
16385int ASN1CALL
16386decode_PA_SERVER_REFERRAL_DATA(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_SERVER_REFERRAL_DATA *data, size_t *size)
16387{
16388size_t ret = 0;
16389size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16390int e HEIMDAL_UNUSED_ATTRIBUTE;
16391
16392memset(data, 0, sizeof(*data));
16393e = decode_EncryptedData(p, len, data, &l);
16394if(e) goto fail;
16395p += l; len -= l; ret += l;
16396if(size) *size = ret;
16397return 0;
16398fail:
16399free_PA_SERVER_REFERRAL_DATA(data);
16400return e;
16401}
16402
16403void ASN1CALL
16404free_PA_SERVER_REFERRAL_DATA(PA_SERVER_REFERRAL_DATA *data)
16405{
16406free_EncryptedData(data);
16407}
16408
16409size_t ASN1CALL
16410length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *data)
16411{
16412size_t ret = 0;
16413ret += length_EncryptedData(data);
16414return ret;
16415}
16416
16417int ASN1CALL
16418copy_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *from, PA_SERVER_REFERRAL_DATA *to)
16419{
16420memset(to, 0, sizeof(*to));
16421if(copy_EncryptedData(from, to)) goto fail;
16422return 0;
16423fail:
16424free_PA_SERVER_REFERRAL_DATA(to);
16425return ENOMEM;
16426}
16427
16428int ASN1CALL
16429encode_PA_ServerReferralData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_ServerReferralData *data, size_t *size)
16430{
16431size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16432size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16433int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16434
16435/* referral-valid-until */
16436if((data)->referral_valid_until) {
16437size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16438ret = 0;
16439e = encode_KerberosTime(p, len, (data)->referral_valid_until, &l);
16440if (e) return e;
16441p -= l; len -= l; ret += l;
16442
16443e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
16444if (e) return e;
16445p -= l; len -= l; ret += l;
16446
16447ret += Top_tag_oldret;
16448}
16449/* requested-principal-name */
16450if((data)->requested_principal_name) {
16451size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16452ret = 0;
16453e = encode_PrincipalName(p, len, (data)->requested_principal_name, &l);
16454if (e) return e;
16455p -= l; len -= l; ret += l;
16456
16457e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
16458if (e) return e;
16459p -= l; len -= l; ret += l;
16460
16461ret += Top_tag_oldret;
16462}
16463/* true-principal-name */
16464if((data)->true_principal_name) {
16465size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16466ret = 0;
16467e = encode_PrincipalName(p, len, (data)->true_principal_name, &l);
16468if (e) return e;
16469p -= l; len -= l; ret += l;
16470
16471e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16472if (e) return e;
16473p -= l; len -= l; ret += l;
16474
16475ret += Top_tag_oldret;
16476}
16477/* referred-realm */
16478if((data)->referred_realm) {
16479size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16480ret = 0;
16481e = encode_Realm(p, len, (data)->referred_realm, &l);
16482if (e) return e;
16483p -= l; len -= l; ret += l;
16484
16485e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16486if (e) return e;
16487p -= l; len -= l; ret += l;
16488
16489ret += Top_tag_oldret;
16490}
16491e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16492if (e) return e;
16493p -= l; len -= l; ret += l;
16494
16495*size = ret;
16496return 0;
16497}
16498
16499int ASN1CALL
16500decode_PA_ServerReferralData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_ServerReferralData *data, size_t *size)
16501{
16502size_t ret = 0;
16503size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16504int e HEIMDAL_UNUSED_ATTRIBUTE;
16505
16506memset(data, 0, sizeof(*data));
16507{
16508size_t Top_datalen, Top_oldlen;
16509Der_type Top_type;
16510e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16511if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16512if(e) goto fail;
16513p += l; len -= l; ret += l;
16514Top_oldlen = len;
16515if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16516len = Top_datalen;
16517{
16518size_t referred_realm_datalen, referred_realm_oldlen;
16519Der_type referred_realm_type;
16520e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referred_realm_type, 0, &referred_realm_datalen, &l);
16521if (e == 0 && referred_realm_type != CONS) { e = ASN1_BAD_ID; }
16522if(e) {
16523(data)->referred_realm = NULL;
16524} else {
16525(data)->referred_realm = calloc(1, sizeof(*(data)->referred_realm));
16526if ((data)->referred_realm == NULL) { e = ENOMEM; goto fail; }
16527p += l; len -= l; ret += l;
16528referred_realm_oldlen = len;
16529if (referred_realm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16530len = referred_realm_datalen;
16531e = decode_Realm(p, len, (data)->referred_realm, &l);
16532if(e) goto fail;
16533p += l; len -= l; ret += l;
16534len = referred_realm_oldlen - referred_realm_datalen;
16535}
16536}
16537{
16538size_t true_principal_name_datalen, true_principal_name_oldlen;
16539Der_type true_principal_name_type;
16540e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &true_principal_name_type, 1, &true_principal_name_datalen, &l);
16541if (e == 0 && true_principal_name_type != CONS) { e = ASN1_BAD_ID; }
16542if(e) {
16543(data)->true_principal_name = NULL;
16544} else {
16545(data)->true_principal_name = calloc(1, sizeof(*(data)->true_principal_name));
16546if ((data)->true_principal_name == NULL) { e = ENOMEM; goto fail; }
16547p += l; len -= l; ret += l;
16548true_principal_name_oldlen = len;
16549if (true_principal_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16550len = true_principal_name_datalen;
16551e = decode_PrincipalName(p, len, (data)->true_principal_name, &l);
16552if(e) goto fail;
16553p += l; len -= l; ret += l;
16554len = true_principal_name_oldlen - true_principal_name_datalen;
16555}
16556}
16557{
16558size_t requested_principal_name_datalen, requested_principal_name_oldlen;
16559Der_type requested_principal_name_type;
16560e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &requested_principal_name_type, 2, &requested_principal_name_datalen, &l);
16561if (e == 0 && requested_principal_name_type != CONS) { e = ASN1_BAD_ID; }
16562if(e) {
16563(data)->requested_principal_name = NULL;
16564} else {
16565(data)->requested_principal_name = calloc(1, sizeof(*(data)->requested_principal_name));
16566if ((data)->requested_principal_name == NULL) { e = ENOMEM; goto fail; }
16567p += l; len -= l; ret += l;
16568requested_principal_name_oldlen = len;
16569if (requested_principal_name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16570len = requested_principal_name_datalen;
16571e = decode_PrincipalName(p, len, (data)->requested_principal_name, &l);
16572if(e) goto fail;
16573p += l; len -= l; ret += l;
16574len = requested_principal_name_oldlen - requested_principal_name_datalen;
16575}
16576}
16577{
16578size_t referral_valid_until_datalen, referral_valid_until_oldlen;
16579Der_type referral_valid_until_type;
16580e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &referral_valid_until_type, 3, &referral_valid_until_datalen, &l);
16581if (e == 0 && referral_valid_until_type != CONS) { e = ASN1_BAD_ID; }
16582if(e) {
16583(data)->referral_valid_until = NULL;
16584} else {
16585(data)->referral_valid_until = calloc(1, sizeof(*(data)->referral_valid_until));
16586if ((data)->referral_valid_until == NULL) { e = ENOMEM; goto fail; }
16587p += l; len -= l; ret += l;
16588referral_valid_until_oldlen = len;
16589if (referral_valid_until_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16590len = referral_valid_until_datalen;
16591e = decode_KerberosTime(p, len, (data)->referral_valid_until, &l);
16592if(e) goto fail;
16593p += l; len -= l; ret += l;
16594len = referral_valid_until_oldlen - referral_valid_until_datalen;
16595}
16596}
16597len = Top_oldlen - Top_datalen;
16598}
16599if(size) *size = ret;
16600return 0;
16601fail:
16602free_PA_ServerReferralData(data);
16603return e;
16604}
16605
16606void ASN1CALL
16607free_PA_ServerReferralData(PA_ServerReferralData *data)
16608{
16609if((data)->referred_realm) {
16610free_Realm((data)->referred_realm);
16611free((data)->referred_realm);
16612(data)->referred_realm = NULL;
16613}
16614if((data)->true_principal_name) {
16615free_PrincipalName((data)->true_principal_name);
16616free((data)->true_principal_name);
16617(data)->true_principal_name = NULL;
16618}
16619if((data)->requested_principal_name) {
16620free_PrincipalName((data)->requested_principal_name);
16621free((data)->requested_principal_name);
16622(data)->requested_principal_name = NULL;
16623}
16624if((data)->referral_valid_until) {
16625free_KerberosTime((data)->referral_valid_until);
16626free((data)->referral_valid_until);
16627(data)->referral_valid_until = NULL;
16628}
16629}
16630
16631size_t ASN1CALL
16632length_PA_ServerReferralData(const PA_ServerReferralData *data)
16633{
16634size_t ret = 0;
16635if((data)->referred_realm){
16636size_t Top_tag_oldret = ret;
16637ret = 0;
16638ret += length_Realm((data)->referred_realm);
16639ret += 1 + der_length_len (ret);
16640ret += Top_tag_oldret;
16641}
16642if((data)->true_principal_name){
16643size_t Top_tag_oldret = ret;
16644ret = 0;
16645ret += length_PrincipalName((data)->true_principal_name);
16646ret += 1 + der_length_len (ret);
16647ret += Top_tag_oldret;
16648}
16649if((data)->requested_principal_name){
16650size_t Top_tag_oldret = ret;
16651ret = 0;
16652ret += length_PrincipalName((data)->requested_principal_name);
16653ret += 1 + der_length_len (ret);
16654ret += Top_tag_oldret;
16655}
16656if((data)->referral_valid_until){
16657size_t Top_tag_oldret = ret;
16658ret = 0;
16659ret += length_KerberosTime((data)->referral_valid_until);
16660ret += 1 + der_length_len (ret);
16661ret += Top_tag_oldret;
16662}
16663ret += 1 + der_length_len (ret);
16664return ret;
16665}
16666
16667int ASN1CALL
16668copy_PA_ServerReferralData(const PA_ServerReferralData *from, PA_ServerReferralData *to)
16669{
16670memset(to, 0, sizeof(*to));
16671if((from)->referred_realm) {
16672(to)->referred_realm = malloc(sizeof(*(to)->referred_realm));
16673if((to)->referred_realm == NULL) goto fail;
16674if(copy_Realm((from)->referred_realm, (to)->referred_realm)) goto fail;
16675}else
16676(to)->referred_realm = NULL;
16677if((from)->true_principal_name) {
16678(to)->true_principal_name = malloc(sizeof(*(to)->true_principal_name));
16679if((to)->true_principal_name == NULL) goto fail;
16680if(copy_PrincipalName((from)->true_principal_name, (to)->true_principal_name)) goto fail;
16681}else
16682(to)->true_principal_name = NULL;
16683if((from)->requested_principal_name) {
16684(to)->requested_principal_name = malloc(sizeof(*(to)->requested_principal_name));
16685if((to)->requested_principal_name == NULL) goto fail;
16686if(copy_PrincipalName((from)->requested_principal_name, (to)->requested_principal_name)) goto fail;
16687}else
16688(to)->requested_principal_name = NULL;
16689if((from)->referral_valid_until) {
16690(to)->referral_valid_until = malloc(sizeof(*(to)->referral_valid_until));
16691if((to)->referral_valid_until == NULL) goto fail;
16692if(copy_KerberosTime((from)->referral_valid_until, (to)->referral_valid_until)) goto fail;
16693}else
16694(to)->referral_valid_until = NULL;
16695return 0;
16696fail:
16697free_PA_ServerReferralData(to);
16698return ENOMEM;
16699}
16700
16701int ASN1CALL
16702encode_FastOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const FastOptions *data, size_t *size)
16703{
16704size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16705size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16706int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16707
16708{
16709unsigned char c = 0;
16710if (len < 1) return ASN1_OVERFLOW;
16711*p-- = c; len--; ret++;
16712c = 0;
16713if((data)->kdc_follow_referrals) {
16714c |= 1<<7;
16715}
16716if (len < 1) return ASN1_OVERFLOW;
16717*p-- = c; len--; ret++;
16718c = 0;
16719if (len < 1) return ASN1_OVERFLOW;
16720*p-- = c; len--; ret++;
16721c = 0;
16722if((data)->hide_client_names) {
16723c |= 1<<6;
16724}
16725if((data)->reserved) {
16726c |= 1<<7;
16727}
16728if (len < 1) return ASN1_OVERFLOW;
16729*p-- = c; len--; ret++;
16730if (len < 1) return ASN1_OVERFLOW;
16731*p-- = 0;
16732len -= 1;
16733ret += 1;
16734}
16735
16736e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
16737if (e) return e;
16738p -= l; len -= l; ret += l;
16739
16740*size = ret;
16741return 0;
16742}
16743
16744int ASN1CALL
16745decode_FastOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, FastOptions *data, size_t *size)
16746{
16747size_t ret = 0;
16748size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16749int e HEIMDAL_UNUSED_ATTRIBUTE;
16750
16751memset(data, 0, sizeof(*data));
16752{
16753size_t Top_datalen, Top_oldlen;
16754Der_type Top_type;
16755e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
16756if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
16757if(e) goto fail;
16758p += l; len -= l; ret += l;
16759Top_oldlen = len;
16760if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16761len = Top_datalen;
16762if (len < 1) return ASN1_OVERRUN;
16763p++; len--; ret++;
16764do {
16765if (len < 1) break;
16766(data)->reserved = (*p >> 7) & 1;
16767(data)->hide_client_names = (*p >> 6) & 1;
16768p++; len--; ret++;
16769if (len < 1) break;
16770p++; len--; ret++;
16771if (len < 1) break;
16772(data)->kdc_follow_referrals = (*p >> 7) & 1;
16773} while(0);
16774p += len; ret += len;
16775len = Top_oldlen - Top_datalen;
16776}
16777if(size) *size = ret;
16778return 0;
16779fail:
16780free_FastOptions(data);
16781return e;
16782}
16783
16784void ASN1CALL
16785free_FastOptions(FastOptions *data)
16786{
16787}
16788
16789size_t ASN1CALL
16790length_FastOptions(const FastOptions *data)
16791{
16792size_t ret = 0;
16793ret += 5;
16794ret += 1 + der_length_len (ret);
16795return ret;
16796}
16797
16798int ASN1CALL
16799copy_FastOptions(const FastOptions *from, FastOptions *to)
16800{
16801memset(to, 0, sizeof(*to));
16802*(to) = *(from);
16803return 0;
16804}
16805
16806unsigned FastOptions2int(FastOptions f)
16807{
16808unsigned r = 0;
16809if(f.reserved) r |= (1U << 0);
16810if(f.hide_client_names) r |= (1U << 1);
16811if(f.kdc_follow_referrals) r |= (1U << 16);
16812return r;
16813}
16814
16815FastOptions int2FastOptions(unsigned n)
16816{
16817 FastOptions flags;
16818
16819 memset(&flags, 0, sizeof(flags));
16820
16821 flags.reserved = (n >> 0) & 1;
16822 flags.hide_client_names = (n >> 1) & 1;
16823 flags.kdc_follow_referrals = (n >> 16) & 1;
16824 return flags;
16825}
16826
16827static struct units FastOptions_units[] = {
16828 {"kdc-follow-referrals", 1U << 16},
16829 {"hide-client-names", 1U << 1},
16830 {"reserved", 1U << 0},
16831 {NULL, 0}
16832};
16833
16834const struct units * asn1_FastOptions_units(void){
16835return FastOptions_units;
16836}
16837
16838int ASN1CALL
16839encode_KrbFastReq(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastReq *data, size_t *size)
16840{
16841size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
16842size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16843int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
16844
16845/* req-body */
16846{
16847size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16848ret = 0;
16849e = encode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
16850if (e) return e;
16851p -= l; len -= l; ret += l;
16852
16853e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
16854if (e) return e;
16855p -= l; len -= l; ret += l;
16856
16857ret += Top_tag_oldret;
16858}
16859/* padata */
16860{
16861size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16862ret = 0;
16863e = encode_METHOD_DATA(p, len, &(data)->padata, &l);
16864if (e) return e;
16865p -= l; len -= l; ret += l;
16866
16867e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
16868if (e) return e;
16869p -= l; len -= l; ret += l;
16870
16871ret += Top_tag_oldret;
16872}
16873/* fast-options */
16874{
16875size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
16876ret = 0;
16877e = encode_FastOptions(p, len, &(data)->fast_options, &l);
16878if (e) return e;
16879p -= l; len -= l; ret += l;
16880
16881e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
16882if (e) return e;
16883p -= l; len -= l; ret += l;
16884
16885ret += Top_tag_oldret;
16886}
16887e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
16888if (e) return e;
16889p -= l; len -= l; ret += l;
16890
16891*size = ret;
16892return 0;
16893}
16894
16895int ASN1CALL
16896decode_KrbFastReq(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastReq *data, size_t *size)
16897{
16898size_t ret = 0;
16899size_t l HEIMDAL_UNUSED_ATTRIBUTE;
16900int e HEIMDAL_UNUSED_ATTRIBUTE;
16901
16902memset(data, 0, sizeof(*data));
16903{
16904size_t Top_datalen, Top_oldlen;
16905Der_type Top_type;
16906e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
16907if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
16908if(e) goto fail;
16909p += l; len -= l; ret += l;
16910Top_oldlen = len;
16911if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16912len = Top_datalen;
16913{
16914size_t fast_options_datalen, fast_options_oldlen;
16915Der_type fast_options_type;
16916e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &fast_options_type, 0, &fast_options_datalen, &l);
16917if (e == 0 && fast_options_type != CONS) { e = ASN1_BAD_ID; }
16918if(e) goto fail;
16919p += l; len -= l; ret += l;
16920fast_options_oldlen = len;
16921if (fast_options_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16922len = fast_options_datalen;
16923e = decode_FastOptions(p, len, &(data)->fast_options, &l);
16924if(e) goto fail;
16925p += l; len -= l; ret += l;
16926len = fast_options_oldlen - fast_options_datalen;
16927}
16928{
16929size_t padata_datalen, padata_oldlen;
16930Der_type padata_type;
16931e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 1, &padata_datalen, &l);
16932if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
16933if(e) goto fail;
16934p += l; len -= l; ret += l;
16935padata_oldlen = len;
16936if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16937len = padata_datalen;
16938e = decode_METHOD_DATA(p, len, &(data)->padata, &l);
16939if(e) goto fail;
16940p += l; len -= l; ret += l;
16941len = padata_oldlen - padata_datalen;
16942}
16943{
16944size_t req_body_datalen, req_body_oldlen;
16945Der_type req_body_type;
16946e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &req_body_type, 2, &req_body_datalen, &l);
16947if (e == 0 && req_body_type != CONS) { e = ASN1_BAD_ID; }
16948if(e) goto fail;
16949p += l; len -= l; ret += l;
16950req_body_oldlen = len;
16951if (req_body_datalen > len) { e = ASN1_OVERRUN; goto fail; }
16952len = req_body_datalen;
16953e = decode_KDC_REQ_BODY(p, len, &(data)->req_body, &l);
16954if(e) goto fail;
16955p += l; len -= l; ret += l;
16956len = req_body_oldlen - req_body_datalen;
16957}
16958len = Top_oldlen - Top_datalen;
16959}
16960if(size) *size = ret;
16961return 0;
16962fail:
16963free_KrbFastReq(data);
16964return e;
16965}
16966
16967void ASN1CALL
16968free_KrbFastReq(KrbFastReq *data)
16969{
16970free_FastOptions(&(data)->fast_options);
16971free_METHOD_DATA(&(data)->padata);
16972free_KDC_REQ_BODY(&(data)->req_body);
16973}
16974
16975size_t ASN1CALL
16976length_KrbFastReq(const KrbFastReq *data)
16977{
16978size_t ret = 0;
16979{
16980size_t Top_tag_oldret = ret;
16981ret = 0;
16982ret += length_FastOptions(&(data)->fast_options);
16983ret += 1 + der_length_len (ret);
16984ret += Top_tag_oldret;
16985}
16986{
16987size_t Top_tag_oldret = ret;
16988ret = 0;
16989ret += length_METHOD_DATA(&(data)->padata);
16990ret += 1 + der_length_len (ret);
16991ret += Top_tag_oldret;
16992}
16993{
16994size_t Top_tag_oldret = ret;
16995ret = 0;
16996ret += length_KDC_REQ_BODY(&(data)->req_body);
16997ret += 1 + der_length_len (ret);
16998ret += Top_tag_oldret;
16999}
17000ret += 1 + der_length_len (ret);
17001return ret;
17002}
17003
17004int ASN1CALL
17005copy_KrbFastReq(const KrbFastReq *from, KrbFastReq *to)
17006{
17007memset(to, 0, sizeof(*to));
17008if(copy_FastOptions(&(from)->fast_options, &(to)->fast_options)) goto fail;
17009if(copy_METHOD_DATA(&(from)->padata, &(to)->padata)) goto fail;
17010if(copy_KDC_REQ_BODY(&(from)->req_body, &(to)->req_body)) goto fail;
17011return 0;
17012fail:
17013free_KrbFastReq(to);
17014return ENOMEM;
17015}
17016
17017int ASN1CALL
17018encode_KrbFastArmor(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastArmor *data, size_t *size)
17019{
17020size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17021size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17022int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17023
17024/* armor-value */
17025{
17026size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17027ret = 0;
17028e = der_put_octet_string(p, len, &(data)->armor_value, &l);
17029if (e) return e;
17030p -= l; len -= l; ret += l;
17031
17032e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
17033if (e) return e;
17034p -= l; len -= l; ret += l;
17035
17036e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17037if (e) return e;
17038p -= l; len -= l; ret += l;
17039
17040ret += Top_tag_oldret;
17041}
17042/* armor-type */
17043{
17044size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17045ret = 0;
17046e = encode_krb5int32(p, len, &(data)->armor_type, &l);
17047if (e) return e;
17048p -= l; len -= l; ret += l;
17049
17050e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17051if (e) return e;
17052p -= l; len -= l; ret += l;
17053
17054ret += Top_tag_oldret;
17055}
17056e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17057if (e) return e;
17058p -= l; len -= l; ret += l;
17059
17060*size = ret;
17061return 0;
17062}
17063
17064int ASN1CALL
17065decode_KrbFastArmor(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastArmor *data, size_t *size)
17066{
17067size_t ret = 0;
17068size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17069int e HEIMDAL_UNUSED_ATTRIBUTE;
17070
17071memset(data, 0, sizeof(*data));
17072{
17073size_t Top_datalen, Top_oldlen;
17074Der_type Top_type;
17075e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17076if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17077if(e) goto fail;
17078p += l; len -= l; ret += l;
17079Top_oldlen = len;
17080if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17081len = Top_datalen;
17082{
17083size_t armor_type_datalen, armor_type_oldlen;
17084Der_type armor_type_type;
17085e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_type_type, 0, &armor_type_datalen, &l);
17086if (e == 0 && armor_type_type != CONS) { e = ASN1_BAD_ID; }
17087if(e) goto fail;
17088p += l; len -= l; ret += l;
17089armor_type_oldlen = len;
17090if (armor_type_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17091len = armor_type_datalen;
17092e = decode_krb5int32(p, len, &(data)->armor_type, &l);
17093if(e) goto fail;
17094p += l; len -= l; ret += l;
17095len = armor_type_oldlen - armor_type_datalen;
17096}
17097{
17098size_t armor_value_datalen, armor_value_oldlen;
17099Der_type armor_value_type;
17100e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_value_type, 1, &armor_value_datalen, &l);
17101if (e == 0 && armor_value_type != CONS) { e = ASN1_BAD_ID; }
17102if(e) goto fail;
17103p += l; len -= l; ret += l;
17104armor_value_oldlen = len;
17105if (armor_value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17106len = armor_value_datalen;
17107{
17108size_t armor_value_Tag_datalen, armor_value_Tag_oldlen;
17109Der_type armor_value_Tag_type;
17110e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &armor_value_Tag_type, UT_OctetString, &armor_value_Tag_datalen, &l);
17111if (e == 0 && armor_value_Tag_type != PRIM) { e = ASN1_BAD_ID; }
17112if(e) goto fail;
17113p += l; len -= l; ret += l;
17114armor_value_Tag_oldlen = len;
17115if (armor_value_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17116len = armor_value_Tag_datalen;
17117e = der_get_octet_string(p, len, &(data)->armor_value, &l);
17118if(e) goto fail;
17119p += l; len -= l; ret += l;
17120len = armor_value_Tag_oldlen - armor_value_Tag_datalen;
17121}
17122len = armor_value_oldlen - armor_value_datalen;
17123}
17124len = Top_oldlen - Top_datalen;
17125}
17126if(size) *size = ret;
17127return 0;
17128fail:
17129free_KrbFastArmor(data);
17130return e;
17131}
17132
17133void ASN1CALL
17134free_KrbFastArmor(KrbFastArmor *data)
17135{
17136free_krb5int32(&(data)->armor_type);
17137der_free_octet_string(&(data)->armor_value);
17138}
17139
17140size_t ASN1CALL
17141length_KrbFastArmor(const KrbFastArmor *data)
17142{
17143size_t ret = 0;
17144{
17145size_t Top_tag_oldret = ret;
17146ret = 0;
17147ret += length_krb5int32(&(data)->armor_type);
17148ret += 1 + der_length_len (ret);
17149ret += Top_tag_oldret;
17150}
17151{
17152size_t Top_tag_oldret = ret;
17153ret = 0;
17154ret += der_length_octet_string(&(data)->armor_value);
17155ret += 1 + der_length_len (ret);
17156ret += 1 + der_length_len (ret);
17157ret += Top_tag_oldret;
17158}
17159ret += 1 + der_length_len (ret);
17160return ret;
17161}
17162
17163int ASN1CALL
17164copy_KrbFastArmor(const KrbFastArmor *from, KrbFastArmor *to)
17165{
17166memset(to, 0, sizeof(*to));
17167if(copy_krb5int32(&(from)->armor_type, &(to)->armor_type)) goto fail;
17168if(der_copy_octet_string(&(from)->armor_value, &(to)->armor_value)) goto fail;
17169return 0;
17170fail:
17171free_KrbFastArmor(to);
17172return ENOMEM;
17173}
17174
17175int ASN1CALL
17176encode_KrbFastArmoredReq(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastArmoredReq *data, size_t *size)
17177{
17178size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17179size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17180int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17181
17182/* enc-fast-req */
17183{
17184size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17185ret = 0;
17186e = encode_EncryptedData(p, len, &(data)->enc_fast_req, &l);
17187if (e) return e;
17188p -= l; len -= l; ret += l;
17189
17190e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
17191if (e) return e;
17192p -= l; len -= l; ret += l;
17193
17194ret += Top_tag_oldret;
17195}
17196/* req-checksum */
17197{
17198size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17199ret = 0;
17200e = encode_Checksum(p, len, &(data)->req_checksum, &l);
17201if (e) return e;
17202p -= l; len -= l; ret += l;
17203
17204e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17205if (e) return e;
17206p -= l; len -= l; ret += l;
17207
17208ret += Top_tag_oldret;
17209}
17210/* armor */
17211if((data)->armor) {
17212size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17213ret = 0;
17214e = encode_KrbFastArmor(p, len, (data)->armor, &l);
17215if (e) return e;
17216p -= l; len -= l; ret += l;
17217
17218e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17219if (e) return e;
17220p -= l; len -= l; ret += l;
17221
17222ret += Top_tag_oldret;
17223}
17224e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17225if (e) return e;
17226p -= l; len -= l; ret += l;
17227
17228*size = ret;
17229return 0;
17230}
17231
17232int ASN1CALL
17233decode_KrbFastArmoredReq(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastArmoredReq *data, size_t *size)
17234{
17235size_t ret = 0;
17236size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17237int e HEIMDAL_UNUSED_ATTRIBUTE;
17238
17239memset(data, 0, sizeof(*data));
17240{
17241size_t Top_datalen, Top_oldlen;
17242Der_type Top_type;
17243e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17244if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17245if(e) goto fail;
17246p += l; len -= l; ret += l;
17247Top_oldlen = len;
17248if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17249len = Top_datalen;
17250{
17251size_t armor_datalen, armor_oldlen;
17252Der_type armor_type;
17253e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_type, 0, &armor_datalen, &l);
17254if (e == 0 && armor_type != CONS) { e = ASN1_BAD_ID; }
17255if(e) {
17256(data)->armor = NULL;
17257} else {
17258(data)->armor = calloc(1, sizeof(*(data)->armor));
17259if ((data)->armor == NULL) { e = ENOMEM; goto fail; }
17260p += l; len -= l; ret += l;
17261armor_oldlen = len;
17262if (armor_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17263len = armor_datalen;
17264e = decode_KrbFastArmor(p, len, (data)->armor, &l);
17265if(e) goto fail;
17266p += l; len -= l; ret += l;
17267len = armor_oldlen - armor_datalen;
17268}
17269}
17270{
17271size_t req_checksum_datalen, req_checksum_oldlen;
17272Der_type req_checksum_type;
17273e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &req_checksum_type, 1, &req_checksum_datalen, &l);
17274if (e == 0 && req_checksum_type != CONS) { e = ASN1_BAD_ID; }
17275if(e) goto fail;
17276p += l; len -= l; ret += l;
17277req_checksum_oldlen = len;
17278if (req_checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17279len = req_checksum_datalen;
17280e = decode_Checksum(p, len, &(data)->req_checksum, &l);
17281if(e) goto fail;
17282p += l; len -= l; ret += l;
17283len = req_checksum_oldlen - req_checksum_datalen;
17284}
17285{
17286size_t enc_fast_req_datalen, enc_fast_req_oldlen;
17287Der_type enc_fast_req_type;
17288e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_fast_req_type, 2, &enc_fast_req_datalen, &l);
17289if (e == 0 && enc_fast_req_type != CONS) { e = ASN1_BAD_ID; }
17290if(e) goto fail;
17291p += l; len -= l; ret += l;
17292enc_fast_req_oldlen = len;
17293if (enc_fast_req_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17294len = enc_fast_req_datalen;
17295e = decode_EncryptedData(p, len, &(data)->enc_fast_req, &l);
17296if(e) goto fail;
17297p += l; len -= l; ret += l;
17298len = enc_fast_req_oldlen - enc_fast_req_datalen;
17299}
17300len = Top_oldlen - Top_datalen;
17301}
17302if(size) *size = ret;
17303return 0;
17304fail:
17305free_KrbFastArmoredReq(data);
17306return e;
17307}
17308
17309void ASN1CALL
17310free_KrbFastArmoredReq(KrbFastArmoredReq *data)
17311{
17312if((data)->armor) {
17313free_KrbFastArmor((data)->armor);
17314free((data)->armor);
17315(data)->armor = NULL;
17316}
17317free_Checksum(&(data)->req_checksum);
17318free_EncryptedData(&(data)->enc_fast_req);
17319}
17320
17321size_t ASN1CALL
17322length_KrbFastArmoredReq(const KrbFastArmoredReq *data)
17323{
17324size_t ret = 0;
17325if((data)->armor){
17326size_t Top_tag_oldret = ret;
17327ret = 0;
17328ret += length_KrbFastArmor((data)->armor);
17329ret += 1 + der_length_len (ret);
17330ret += Top_tag_oldret;
17331}
17332{
17333size_t Top_tag_oldret = ret;
17334ret = 0;
17335ret += length_Checksum(&(data)->req_checksum);
17336ret += 1 + der_length_len (ret);
17337ret += Top_tag_oldret;
17338}
17339{
17340size_t Top_tag_oldret = ret;
17341ret = 0;
17342ret += length_EncryptedData(&(data)->enc_fast_req);
17343ret += 1 + der_length_len (ret);
17344ret += Top_tag_oldret;
17345}
17346ret += 1 + der_length_len (ret);
17347return ret;
17348}
17349
17350int ASN1CALL
17351copy_KrbFastArmoredReq(const KrbFastArmoredReq *from, KrbFastArmoredReq *to)
17352{
17353memset(to, 0, sizeof(*to));
17354if((from)->armor) {
17355(to)->armor = malloc(sizeof(*(to)->armor));
17356if((to)->armor == NULL) goto fail;
17357if(copy_KrbFastArmor((from)->armor, (to)->armor)) goto fail;
17358}else
17359(to)->armor = NULL;
17360if(copy_Checksum(&(from)->req_checksum, &(to)->req_checksum)) goto fail;
17361if(copy_EncryptedData(&(from)->enc_fast_req, &(to)->enc_fast_req)) goto fail;
17362return 0;
17363fail:
17364free_KrbFastArmoredReq(to);
17365return ENOMEM;
17366}
17367
17368int ASN1CALL
17369encode_PA_FX_FAST_REQUEST(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_FX_FAST_REQUEST *data, size_t *size)
17370{
17371size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17372size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17373int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17374
17375
17376switch((data)->element) {
17377case choice_PA_FX_FAST_REQUEST_armored_data: {size_t Top_oldret = ret;
17378ret = 0;
17379e = encode_KrbFastArmoredReq(p, len, &((data))->u.armored_data, &l);
17380if (e) return e;
17381p -= l; len -= l; ret += l;
17382
17383e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17384if (e) return e;
17385p -= l; len -= l; ret += l;
17386
17387ret += Top_oldret;
17388break;
17389}
17390case choice_PA_FX_FAST_REQUEST_asn1_ellipsis: {
17391if (len < (data)->u.asn1_ellipsis.length)
17392return ASN1_OVERFLOW;
17393p -= (data)->u.asn1_ellipsis.length;
17394ret += (data)->u.asn1_ellipsis.length;
17395memcpy(p + 1, (data)->u.asn1_ellipsis.data, (data)->u.asn1_ellipsis.length);
17396break;
17397}
17398};
17399*size = ret;
17400return 0;
17401}
17402
17403int ASN1CALL
17404decode_PA_FX_FAST_REQUEST(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_FX_FAST_REQUEST *data, size_t *size)
17405{
17406size_t ret = 0;
17407size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17408int e HEIMDAL_UNUSED_ATTRIBUTE;
17409
17410memset(data, 0, sizeof(*data));
17411if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
17412{
17413size_t armored_data_datalen, armored_data_oldlen;
17414Der_type armored_data_type;
17415e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armored_data_type, 0, &armored_data_datalen, &l);
17416if (e == 0 && armored_data_type != CONS) { e = ASN1_BAD_ID; }
17417if(e) goto fail;
17418p += l; len -= l; ret += l;
17419armored_data_oldlen = len;
17420if (armored_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17421len = armored_data_datalen;
17422e = decode_KrbFastArmoredReq(p, len, &(data)->u.armored_data, &l);
17423if(e) goto fail;
17424p += l; len -= l; ret += l;
17425len = armored_data_oldlen - armored_data_datalen;
17426}
17427(data)->element = choice_PA_FX_FAST_REQUEST_armored_data;
17428}
17429else {
17430(data)->u.asn1_ellipsis.data = calloc(1, len);
17431if ((data)->u.asn1_ellipsis.data == NULL) {
17432e = ENOMEM; goto fail;
17433}
17434(data)->u.asn1_ellipsis.length = len;
17435memcpy((data)->u.asn1_ellipsis.data, p, len);
17436(data)->element = choice_PA_FX_FAST_REQUEST_asn1_ellipsis;
17437p += len;
17438ret += len;
17439len = 0;
17440}
17441if(size) *size = ret;
17442return 0;
17443fail:
17444free_PA_FX_FAST_REQUEST(data);
17445return e;
17446}
17447
17448void ASN1CALL
17449free_PA_FX_FAST_REQUEST(PA_FX_FAST_REQUEST *data)
17450{
17451switch((data)->element) {
17452case choice_PA_FX_FAST_REQUEST_armored_data:
17453free_KrbFastArmoredReq(&(data)->u.armored_data);
17454break;
17455case choice_PA_FX_FAST_REQUEST_asn1_ellipsis:
17456der_free_octet_string(&(data)->u.asn1_ellipsis);
17457break;}
17458}
17459
17460size_t ASN1CALL
17461length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *data)
17462{
17463size_t ret = 0;
17464switch((data)->element) {
17465case choice_PA_FX_FAST_REQUEST_armored_data:
17466{
17467size_t Top_oldret = ret;
17468ret = 0;
17469ret += length_KrbFastArmoredReq(&(data)->u.armored_data);
17470ret += 1 + der_length_len (ret);
17471ret += Top_oldret;
17472}
17473break;
17474case choice_PA_FX_FAST_REQUEST_asn1_ellipsis:
17475ret += (data)->u.asn1_ellipsis.length;
17476break;
17477}
17478return ret;
17479}
17480
17481int ASN1CALL
17482copy_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *from, PA_FX_FAST_REQUEST *to)
17483{
17484memset(to, 0, sizeof(*to));
17485(to)->element = (from)->element;
17486switch((from)->element) {
17487case choice_PA_FX_FAST_REQUEST_armored_data:
17488if(copy_KrbFastArmoredReq(&(from)->u.armored_data, &(to)->u.armored_data)) goto fail;
17489break;
17490case choice_PA_FX_FAST_REQUEST_asn1_ellipsis: {
17491int ret;
17492ret=der_copy_octet_string(&(from)->u.asn1_ellipsis, &(to)->u.asn1_ellipsis);
17493if (ret) goto fail;
17494break;
17495}
17496}
17497return 0;
17498fail:
17499free_PA_FX_FAST_REQUEST(to);
17500return ENOMEM;
17501}
17502
17503int ASN1CALL
17504encode_KrbFastFinished(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastFinished *data, size_t *size)
17505{
17506size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17507size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17508int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17509
17510/* ticket-checksum */
17511{
17512size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17513ret = 0;
17514e = encode_Checksum(p, len, &(data)->ticket_checksum, &l);
17515if (e) return e;
17516p -= l; len -= l; ret += l;
17517
17518e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
17519if (e) return e;
17520p -= l; len -= l; ret += l;
17521
17522ret += Top_tag_oldret;
17523}
17524/* cname */
17525{
17526size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17527ret = 0;
17528e = encode_PrincipalName(p, len, &(data)->cname, &l);
17529if (e) return e;
17530p -= l; len -= l; ret += l;
17531
17532e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
17533if (e) return e;
17534p -= l; len -= l; ret += l;
17535
17536ret += Top_tag_oldret;
17537}
17538/* crealm */
17539{
17540size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17541ret = 0;
17542e = encode_Realm(p, len, &(data)->crealm, &l);
17543if (e) return e;
17544p -= l; len -= l; ret += l;
17545
17546e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
17547if (e) return e;
17548p -= l; len -= l; ret += l;
17549
17550ret += Top_tag_oldret;
17551}
17552/* usec */
17553{
17554size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17555ret = 0;
17556e = encode_krb5int32(p, len, &(data)->usec, &l);
17557if (e) return e;
17558p -= l; len -= l; ret += l;
17559
17560e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17561if (e) return e;
17562p -= l; len -= l; ret += l;
17563
17564ret += Top_tag_oldret;
17565}
17566/* timestamp */
17567{
17568size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17569ret = 0;
17570e = encode_KerberosTime(p, len, &(data)->timestamp, &l);
17571if (e) return e;
17572p -= l; len -= l; ret += l;
17573
17574e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17575if (e) return e;
17576p -= l; len -= l; ret += l;
17577
17578ret += Top_tag_oldret;
17579}
17580e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17581if (e) return e;
17582p -= l; len -= l; ret += l;
17583
17584*size = ret;
17585return 0;
17586}
17587
17588int ASN1CALL
17589decode_KrbFastFinished(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastFinished *data, size_t *size)
17590{
17591size_t ret = 0;
17592size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17593int e HEIMDAL_UNUSED_ATTRIBUTE;
17594
17595memset(data, 0, sizeof(*data));
17596{
17597size_t Top_datalen, Top_oldlen;
17598Der_type Top_type;
17599e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17600if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17601if(e) goto fail;
17602p += l; len -= l; ret += l;
17603Top_oldlen = len;
17604if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17605len = Top_datalen;
17606{
17607size_t timestamp_datalen, timestamp_oldlen;
17608Der_type timestamp_type;
17609e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &timestamp_type, 0, &timestamp_datalen, &l);
17610if (e == 0 && timestamp_type != CONS) { e = ASN1_BAD_ID; }
17611if(e) goto fail;
17612p += l; len -= l; ret += l;
17613timestamp_oldlen = len;
17614if (timestamp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17615len = timestamp_datalen;
17616e = decode_KerberosTime(p, len, &(data)->timestamp, &l);
17617if(e) goto fail;
17618p += l; len -= l; ret += l;
17619len = timestamp_oldlen - timestamp_datalen;
17620}
17621{
17622size_t usec_datalen, usec_oldlen;
17623Der_type usec_type;
17624e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &usec_type, 1, &usec_datalen, &l);
17625if (e == 0 && usec_type != CONS) { e = ASN1_BAD_ID; }
17626if(e) goto fail;
17627p += l; len -= l; ret += l;
17628usec_oldlen = len;
17629if (usec_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17630len = usec_datalen;
17631e = decode_krb5int32(p, len, &(data)->usec, &l);
17632if(e) goto fail;
17633p += l; len -= l; ret += l;
17634len = usec_oldlen - usec_datalen;
17635}
17636{
17637size_t crealm_datalen, crealm_oldlen;
17638Der_type crealm_type;
17639e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crealm_type, 2, &crealm_datalen, &l);
17640if (e == 0 && crealm_type != CONS) { e = ASN1_BAD_ID; }
17641if(e) goto fail;
17642p += l; len -= l; ret += l;
17643crealm_oldlen = len;
17644if (crealm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17645len = crealm_datalen;
17646e = decode_Realm(p, len, &(data)->crealm, &l);
17647if(e) goto fail;
17648p += l; len -= l; ret += l;
17649len = crealm_oldlen - crealm_datalen;
17650}
17651{
17652size_t cname_datalen, cname_oldlen;
17653Der_type cname_type;
17654e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cname_type, 3, &cname_datalen, &l);
17655if (e == 0 && cname_type != CONS) { e = ASN1_BAD_ID; }
17656if(e) goto fail;
17657p += l; len -= l; ret += l;
17658cname_oldlen = len;
17659if (cname_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17660len = cname_datalen;
17661e = decode_PrincipalName(p, len, &(data)->cname, &l);
17662if(e) goto fail;
17663p += l; len -= l; ret += l;
17664len = cname_oldlen - cname_datalen;
17665}
17666{
17667size_t ticket_checksum_datalen, ticket_checksum_oldlen;
17668Der_type ticket_checksum_type;
17669e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_checksum_type, 4, &ticket_checksum_datalen, &l);
17670if (e == 0 && ticket_checksum_type != CONS) { e = ASN1_BAD_ID; }
17671if(e) goto fail;
17672p += l; len -= l; ret += l;
17673ticket_checksum_oldlen = len;
17674if (ticket_checksum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17675len = ticket_checksum_datalen;
17676e = decode_Checksum(p, len, &(data)->ticket_checksum, &l);
17677if(e) goto fail;
17678p += l; len -= l; ret += l;
17679len = ticket_checksum_oldlen - ticket_checksum_datalen;
17680}
17681len = Top_oldlen - Top_datalen;
17682}
17683if(size) *size = ret;
17684return 0;
17685fail:
17686free_KrbFastFinished(data);
17687return e;
17688}
17689
17690void ASN1CALL
17691free_KrbFastFinished(KrbFastFinished *data)
17692{
17693free_KerberosTime(&(data)->timestamp);
17694free_krb5int32(&(data)->usec);
17695free_Realm(&(data)->crealm);
17696free_PrincipalName(&(data)->cname);
17697free_Checksum(&(data)->ticket_checksum);
17698}
17699
17700size_t ASN1CALL
17701length_KrbFastFinished(const KrbFastFinished *data)
17702{
17703size_t ret = 0;
17704{
17705size_t Top_tag_oldret = ret;
17706ret = 0;
17707ret += length_KerberosTime(&(data)->timestamp);
17708ret += 1 + der_length_len (ret);
17709ret += Top_tag_oldret;
17710}
17711{
17712size_t Top_tag_oldret = ret;
17713ret = 0;
17714ret += length_krb5int32(&(data)->usec);
17715ret += 1 + der_length_len (ret);
17716ret += Top_tag_oldret;
17717}
17718{
17719size_t Top_tag_oldret = ret;
17720ret = 0;
17721ret += length_Realm(&(data)->crealm);
17722ret += 1 + der_length_len (ret);
17723ret += Top_tag_oldret;
17724}
17725{
17726size_t Top_tag_oldret = ret;
17727ret = 0;
17728ret += length_PrincipalName(&(data)->cname);
17729ret += 1 + der_length_len (ret);
17730ret += Top_tag_oldret;
17731}
17732{
17733size_t Top_tag_oldret = ret;
17734ret = 0;
17735ret += length_Checksum(&(data)->ticket_checksum);
17736ret += 1 + der_length_len (ret);
17737ret += Top_tag_oldret;
17738}
17739ret += 1 + der_length_len (ret);
17740return ret;
17741}
17742
17743int ASN1CALL
17744copy_KrbFastFinished(const KrbFastFinished *from, KrbFastFinished *to)
17745{
17746memset(to, 0, sizeof(*to));
17747if(copy_KerberosTime(&(from)->timestamp, &(to)->timestamp)) goto fail;
17748if(copy_krb5int32(&(from)->usec, &(to)->usec)) goto fail;
17749if(copy_Realm(&(from)->crealm, &(to)->crealm)) goto fail;
17750if(copy_PrincipalName(&(from)->cname, &(to)->cname)) goto fail;
17751if(copy_Checksum(&(from)->ticket_checksum, &(to)->ticket_checksum)) goto fail;
17752return 0;
17753fail:
17754free_KrbFastFinished(to);
17755return ENOMEM;
17756}
17757
17758int ASN1CALL
17759encode_KrbFastResponse(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastResponse *data, size_t *size)
17760{
17761size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
17762size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17763int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
17764
17765/* nonce */
17766{
17767size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17768ret = 0;
17769e = encode_krb5uint32(p, len, &(data)->nonce, &l);
17770if (e) return e;
17771p -= l; len -= l; ret += l;
17772
17773e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
17774if (e) return e;
17775p -= l; len -= l; ret += l;
17776
17777ret += Top_tag_oldret;
17778}
17779/* finished */
17780if((data)->finished) {
17781size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17782ret = 0;
17783e = encode_KrbFastFinished(p, len, (data)->finished, &l);
17784if (e) return e;
17785p -= l; len -= l; ret += l;
17786
17787e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
17788if (e) return e;
17789p -= l; len -= l; ret += l;
17790
17791ret += Top_tag_oldret;
17792}
17793/* strengthen-key */
17794if((data)->strengthen_key) {
17795size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17796ret = 0;
17797e = encode_EncryptionKey(p, len, (data)->strengthen_key, &l);
17798if (e) return e;
17799p -= l; len -= l; ret += l;
17800
17801e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
17802if (e) return e;
17803p -= l; len -= l; ret += l;
17804
17805ret += Top_tag_oldret;
17806}
17807/* padata */
17808{
17809size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
17810ret = 0;
17811e = encode_METHOD_DATA(p, len, &(data)->padata, &l);
17812if (e) return e;
17813p -= l; len -= l; ret += l;
17814
17815e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
17816if (e) return e;
17817p -= l; len -= l; ret += l;
17818
17819ret += Top_tag_oldret;
17820}
17821e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
17822if (e) return e;
17823p -= l; len -= l; ret += l;
17824
17825*size = ret;
17826return 0;
17827}
17828
17829int ASN1CALL
17830decode_KrbFastResponse(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastResponse *data, size_t *size)
17831{
17832size_t ret = 0;
17833size_t l HEIMDAL_UNUSED_ATTRIBUTE;
17834int e HEIMDAL_UNUSED_ATTRIBUTE;
17835
17836memset(data, 0, sizeof(*data));
17837{
17838size_t Top_datalen, Top_oldlen;
17839Der_type Top_type;
17840e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
17841if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
17842if(e) goto fail;
17843p += l; len -= l; ret += l;
17844Top_oldlen = len;
17845if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17846len = Top_datalen;
17847{
17848size_t padata_datalen, padata_oldlen;
17849Der_type padata_type;
17850e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 0, &padata_datalen, &l);
17851if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
17852if(e) goto fail;
17853p += l; len -= l; ret += l;
17854padata_oldlen = len;
17855if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17856len = padata_datalen;
17857e = decode_METHOD_DATA(p, len, &(data)->padata, &l);
17858if(e) goto fail;
17859p += l; len -= l; ret += l;
17860len = padata_oldlen - padata_datalen;
17861}
17862{
17863size_t strengthen_key_datalen, strengthen_key_oldlen;
17864Der_type strengthen_key_type;
17865e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &strengthen_key_type, 1, &strengthen_key_datalen, &l);
17866if (e == 0 && strengthen_key_type != CONS) { e = ASN1_BAD_ID; }
17867if(e) {
17868(data)->strengthen_key = NULL;
17869} else {
17870(data)->strengthen_key = calloc(1, sizeof(*(data)->strengthen_key));
17871if ((data)->strengthen_key == NULL) { e = ENOMEM; goto fail; }
17872p += l; len -= l; ret += l;
17873strengthen_key_oldlen = len;
17874if (strengthen_key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17875len = strengthen_key_datalen;
17876e = decode_EncryptionKey(p, len, (data)->strengthen_key, &l);
17877if(e) goto fail;
17878p += l; len -= l; ret += l;
17879len = strengthen_key_oldlen - strengthen_key_datalen;
17880}
17881}
17882{
17883size_t finished_datalen, finished_oldlen;
17884Der_type finished_type;
17885e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &finished_type, 2, &finished_datalen, &l);
17886if (e == 0 && finished_type != CONS) { e = ASN1_BAD_ID; }
17887if(e) {
17888(data)->finished = NULL;
17889} else {
17890(data)->finished = calloc(1, sizeof(*(data)->finished));
17891if ((data)->finished == NULL) { e = ENOMEM; goto fail; }
17892p += l; len -= l; ret += l;
17893finished_oldlen = len;
17894if (finished_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17895len = finished_datalen;
17896e = decode_KrbFastFinished(p, len, (data)->finished, &l);
17897if(e) goto fail;
17898p += l; len -= l; ret += l;
17899len = finished_oldlen - finished_datalen;
17900}
17901}
17902{
17903size_t nonce_datalen, nonce_oldlen;
17904Der_type nonce_type;
17905e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nonce_type, 3, &nonce_datalen, &l);
17906if (e == 0 && nonce_type != CONS) { e = ASN1_BAD_ID; }
17907if(e) goto fail;
17908p += l; len -= l; ret += l;
17909nonce_oldlen = len;
17910if (nonce_datalen > len) { e = ASN1_OVERRUN; goto fail; }
17911len = nonce_datalen;
17912e = decode_krb5uint32(p, len, &(data)->nonce, &l);
17913if(e) goto fail;
17914p += l; len -= l; ret += l;
17915len = nonce_oldlen - nonce_datalen;
17916}
17917len = Top_oldlen - Top_datalen;
17918}
17919if(size) *size = ret;
17920return 0;
17921fail:
17922free_KrbFastResponse(data);
17923return e;
17924}
17925
17926void ASN1CALL
17927free_KrbFastResponse(KrbFastResponse *data)
17928{
17929free_METHOD_DATA(&(data)->padata);
17930if((data)->strengthen_key) {
17931free_EncryptionKey((data)->strengthen_key);
17932free((data)->strengthen_key);
17933(data)->strengthen_key = NULL;
17934}
17935if((data)->finished) {
17936free_KrbFastFinished((data)->finished);
17937free((data)->finished);
17938(data)->finished = NULL;
17939}
17940free_krb5uint32(&(data)->nonce);
17941}
17942
17943size_t ASN1CALL
17944length_KrbFastResponse(const KrbFastResponse *data)
17945{
17946size_t ret = 0;
17947{
17948size_t Top_tag_oldret = ret;
17949ret = 0;
17950ret += length_METHOD_DATA(&(data)->padata);
17951ret += 1 + der_length_len (ret);
17952ret += Top_tag_oldret;
17953}
17954if((data)->strengthen_key){
17955size_t Top_tag_oldret = ret;
17956ret = 0;
17957ret += length_EncryptionKey((data)->strengthen_key);
17958ret += 1 + der_length_len (ret);
17959ret += Top_tag_oldret;
17960}
17961if((data)->finished){
17962size_t Top_tag_oldret = ret;
17963ret = 0;
17964ret += length_KrbFastFinished((data)->finished);
17965ret += 1 + der_length_len (ret);
17966ret += Top_tag_oldret;
17967}
17968{
17969size_t Top_tag_oldret = ret;
17970ret = 0;
17971ret += length_krb5uint32(&(data)->nonce);
17972ret += 1 + der_length_len (ret);
17973ret += Top_tag_oldret;
17974}
17975ret += 1 + der_length_len (ret);
17976return ret;
17977}
17978
17979int ASN1CALL
17980copy_KrbFastResponse(const KrbFastResponse *from, KrbFastResponse *to)
17981{
17982memset(to, 0, sizeof(*to));
17983if(copy_METHOD_DATA(&(from)->padata, &(to)->padata)) goto fail;
17984if((from)->strengthen_key) {
17985(to)->strengthen_key = malloc(sizeof(*(to)->strengthen_key));
17986if((to)->strengthen_key == NULL) goto fail;
17987if(copy_EncryptionKey((from)->strengthen_key, (to)->strengthen_key)) goto fail;
17988}else
17989(to)->strengthen_key = NULL;
17990if((from)->finished) {
17991(to)->finished = malloc(sizeof(*(to)->finished));
17992if((to)->finished == NULL) goto fail;
17993if(copy_KrbFastFinished((from)->finished, (to)->finished)) goto fail;
17994}else
17995(to)->finished = NULL;
17996if(copy_krb5uint32(&(from)->nonce, &(to)->nonce)) goto fail;
17997return 0;
17998fail:
17999free_KrbFastResponse(to);
18000return ENOMEM;
18001}
18002
18003int ASN1CALL
18004encode_KrbFastArmoredRep(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KrbFastArmoredRep *data, size_t *size)
18005{
18006size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18007size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18008int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18009
18010/* enc-fast-rep */
18011{
18012size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18013ret = 0;
18014e = encode_EncryptedData(p, len, &(data)->enc_fast_rep, &l);
18015if (e) return e;
18016p -= l; len -= l; ret += l;
18017
18018e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
18019if (e) return e;
18020p -= l; len -= l; ret += l;
18021
18022ret += Top_tag_oldret;
18023}
18024e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
18025if (e) return e;
18026p -= l; len -= l; ret += l;
18027
18028*size = ret;
18029return 0;
18030}
18031
18032int ASN1CALL
18033decode_KrbFastArmoredRep(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KrbFastArmoredRep *data, size_t *size)
18034{
18035size_t ret = 0;
18036size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18037int e HEIMDAL_UNUSED_ATTRIBUTE;
18038
18039memset(data, 0, sizeof(*data));
18040{
18041size_t Top_datalen, Top_oldlen;
18042Der_type Top_type;
18043e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
18044if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
18045if(e) goto fail;
18046p += l; len -= l; ret += l;
18047Top_oldlen = len;
18048if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18049len = Top_datalen;
18050{
18051size_t enc_fast_rep_datalen, enc_fast_rep_oldlen;
18052Der_type enc_fast_rep_type;
18053e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &enc_fast_rep_type, 0, &enc_fast_rep_datalen, &l);
18054if (e == 0 && enc_fast_rep_type != CONS) { e = ASN1_BAD_ID; }
18055if(e) goto fail;
18056p += l; len -= l; ret += l;
18057enc_fast_rep_oldlen = len;
18058if (enc_fast_rep_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18059len = enc_fast_rep_datalen;
18060e = decode_EncryptedData(p, len, &(data)->enc_fast_rep, &l);
18061if(e) goto fail;
18062p += l; len -= l; ret += l;
18063len = enc_fast_rep_oldlen - enc_fast_rep_datalen;
18064}
18065len = Top_oldlen - Top_datalen;
18066}
18067if(size) *size = ret;
18068return 0;
18069fail:
18070free_KrbFastArmoredRep(data);
18071return e;
18072}
18073
18074void ASN1CALL
18075free_KrbFastArmoredRep(KrbFastArmoredRep *data)
18076{
18077free_EncryptedData(&(data)->enc_fast_rep);
18078}
18079
18080size_t ASN1CALL
18081length_KrbFastArmoredRep(const KrbFastArmoredRep *data)
18082{
18083size_t ret = 0;
18084{
18085size_t Top_tag_oldret = ret;
18086ret = 0;
18087ret += length_EncryptedData(&(data)->enc_fast_rep);
18088ret += 1 + der_length_len (ret);
18089ret += Top_tag_oldret;
18090}
18091ret += 1 + der_length_len (ret);
18092return ret;
18093}
18094
18095int ASN1CALL
18096copy_KrbFastArmoredRep(const KrbFastArmoredRep *from, KrbFastArmoredRep *to)
18097{
18098memset(to, 0, sizeof(*to));
18099if(copy_EncryptedData(&(from)->enc_fast_rep, &(to)->enc_fast_rep)) goto fail;
18100return 0;
18101fail:
18102free_KrbFastArmoredRep(to);
18103return ENOMEM;
18104}
18105
18106int ASN1CALL
18107encode_PA_FX_FAST_REPLY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PA_FX_FAST_REPLY *data, size_t *size)
18108{
18109size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18110size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18111int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18112
18113
18114switch((data)->element) {
18115case choice_PA_FX_FAST_REPLY_armored_data: {size_t Top_oldret = ret;
18116ret = 0;
18117e = encode_KrbFastArmoredRep(p, len, &((data))->u.armored_data, &l);
18118if (e) return e;
18119p -= l; len -= l; ret += l;
18120
18121e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
18122if (e) return e;
18123p -= l; len -= l; ret += l;
18124
18125ret += Top_oldret;
18126break;
18127}
18128case choice_PA_FX_FAST_REPLY_asn1_ellipsis: {
18129if (len < (data)->u.asn1_ellipsis.length)
18130return ASN1_OVERFLOW;
18131p -= (data)->u.asn1_ellipsis.length;
18132ret += (data)->u.asn1_ellipsis.length;
18133memcpy(p + 1, (data)->u.asn1_ellipsis.data, (data)->u.asn1_ellipsis.length);
18134break;
18135}
18136};
18137*size = ret;
18138return 0;
18139}
18140
18141int ASN1CALL
18142decode_PA_FX_FAST_REPLY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PA_FX_FAST_REPLY *data, size_t *size)
18143{
18144size_t ret = 0;
18145size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18146int e HEIMDAL_UNUSED_ATTRIBUTE;
18147
18148memset(data, 0, sizeof(*data));
18149if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
18150{
18151size_t armored_data_datalen, armored_data_oldlen;
18152Der_type armored_data_type;
18153e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armored_data_type, 0, &armored_data_datalen, &l);
18154if (e == 0 && armored_data_type != CONS) { e = ASN1_BAD_ID; }
18155if(e) goto fail;
18156p += l; len -= l; ret += l;
18157armored_data_oldlen = len;
18158if (armored_data_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18159len = armored_data_datalen;
18160e = decode_KrbFastArmoredRep(p, len, &(data)->u.armored_data, &l);
18161if(e) goto fail;
18162p += l; len -= l; ret += l;
18163len = armored_data_oldlen - armored_data_datalen;
18164}
18165(data)->element = choice_PA_FX_FAST_REPLY_armored_data;
18166}
18167else {
18168(data)->u.asn1_ellipsis.data = calloc(1, len);
18169if ((data)->u.asn1_ellipsis.data == NULL) {
18170e = ENOMEM; goto fail;
18171}
18172(data)->u.asn1_ellipsis.length = len;
18173memcpy((data)->u.asn1_ellipsis.data, p, len);
18174(data)->element = choice_PA_FX_FAST_REPLY_asn1_ellipsis;
18175p += len;
18176ret += len;
18177len = 0;
18178}
18179if(size) *size = ret;
18180return 0;
18181fail:
18182free_PA_FX_FAST_REPLY(data);
18183return e;
18184}
18185
18186void ASN1CALL
18187free_PA_FX_FAST_REPLY(PA_FX_FAST_REPLY *data)
18188{
18189switch((data)->element) {
18190case choice_PA_FX_FAST_REPLY_armored_data:
18191free_KrbFastArmoredRep(&(data)->u.armored_data);
18192break;
18193case choice_PA_FX_FAST_REPLY_asn1_ellipsis:
18194der_free_octet_string(&(data)->u.asn1_ellipsis);
18195break;}
18196}
18197
18198size_t ASN1CALL
18199length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *data)
18200{
18201size_t ret = 0;
18202switch((data)->element) {
18203case choice_PA_FX_FAST_REPLY_armored_data:
18204{
18205size_t Top_oldret = ret;
18206ret = 0;
18207ret += length_KrbFastArmoredRep(&(data)->u.armored_data);
18208ret += 1 + der_length_len (ret);
18209ret += Top_oldret;
18210}
18211break;
18212case choice_PA_FX_FAST_REPLY_asn1_ellipsis:
18213ret += (data)->u.asn1_ellipsis.length;
18214break;
18215}
18216return ret;
18217}
18218
18219int ASN1CALL
18220copy_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *from, PA_FX_FAST_REPLY *to)
18221{
18222memset(to, 0, sizeof(*to));
18223(to)->element = (from)->element;
18224switch((from)->element) {
18225case choice_PA_FX_FAST_REPLY_armored_data:
18226if(copy_KrbFastArmoredRep(&(from)->u.armored_data, &(to)->u.armored_data)) goto fail;
18227break;
18228case choice_PA_FX_FAST_REPLY_asn1_ellipsis: {
18229int ret;
18230ret=der_copy_octet_string(&(from)->u.asn1_ellipsis, &(to)->u.asn1_ellipsis);
18231if (ret) goto fail;
18232break;
18233}
18234}
18235return 0;
18236fail:
18237free_PA_FX_FAST_REPLY(to);
18238return ENOMEM;
18239}
18240
18241int ASN1CALL
18242encode_KDCFastFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDCFastFlags *data, size_t *size)
18243{
18244size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18245size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18246int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18247
18248{
18249unsigned char c = 0;
18250if (len < 1) return ASN1_OVERFLOW;
18251*p-- = c; len--; ret++;
18252c = 0;
18253if (len < 1) return ASN1_OVERFLOW;
18254*p-- = c; len--; ret++;
18255c = 0;
18256if (len < 1) return ASN1_OVERFLOW;
18257*p-- = c; len--; ret++;
18258c = 0;
18259if((data)->kdc_verfied) {
18260c |= 1<<4;
18261}
18262if((data)->reply_key_replaced) {
18263c |= 1<<5;
18264}
18265if((data)->reply_key_used) {
18266c |= 1<<6;
18267}
18268if((data)->use_reply_key) {
18269c |= 1<<7;
18270}
18271if (len < 1) return ASN1_OVERFLOW;
18272*p-- = c; len--; ret++;
18273if (len < 1) return ASN1_OVERFLOW;
18274*p-- = 0;
18275len -= 1;
18276ret += 1;
18277}
18278
18279e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
18280if (e) return e;
18281p -= l; len -= l; ret += l;
18282
18283*size = ret;
18284return 0;
18285}
18286
18287int ASN1CALL
18288decode_KDCFastFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDCFastFlags *data, size_t *size)
18289{
18290size_t ret = 0;
18291size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18292int e HEIMDAL_UNUSED_ATTRIBUTE;
18293
18294memset(data, 0, sizeof(*data));
18295{
18296size_t Top_datalen, Top_oldlen;
18297Der_type Top_type;
18298e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
18299if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
18300if(e) goto fail;
18301p += l; len -= l; ret += l;
18302Top_oldlen = len;
18303if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18304len = Top_datalen;
18305if (len < 1) return ASN1_OVERRUN;
18306p++; len--; ret++;
18307do {
18308if (len < 1) break;
18309(data)->use_reply_key = (*p >> 7) & 1;
18310(data)->reply_key_used = (*p >> 6) & 1;
18311(data)->reply_key_replaced = (*p >> 5) & 1;
18312(data)->kdc_verfied = (*p >> 4) & 1;
18313} while(0);
18314p += len; ret += len;
18315len = Top_oldlen - Top_datalen;
18316}
18317if(size) *size = ret;
18318return 0;
18319fail:
18320free_KDCFastFlags(data);
18321return e;
18322}
18323
18324void ASN1CALL
18325free_KDCFastFlags(KDCFastFlags *data)
18326{
18327}
18328
18329size_t ASN1CALL
18330length_KDCFastFlags(const KDCFastFlags *data)
18331{
18332size_t ret = 0;
18333ret += 5;
18334ret += 1 + der_length_len (ret);
18335return ret;
18336}
18337
18338int ASN1CALL
18339copy_KDCFastFlags(const KDCFastFlags *from, KDCFastFlags *to)
18340{
18341memset(to, 0, sizeof(*to));
18342*(to) = *(from);
18343return 0;
18344}
18345
18346unsigned KDCFastFlags2int(KDCFastFlags f)
18347{
18348unsigned r = 0;
18349if(f.use_reply_key) r |= (1U << 0);
18350if(f.reply_key_used) r |= (1U << 1);
18351if(f.reply_key_replaced) r |= (1U << 2);
18352if(f.kdc_verfied) r |= (1U << 3);
18353return r;
18354}
18355
18356KDCFastFlags int2KDCFastFlags(unsigned n)
18357{
18358 KDCFastFlags flags;
18359
18360 memset(&flags, 0, sizeof(flags));
18361
18362 flags.use_reply_key = (n >> 0) & 1;
18363 flags.reply_key_used = (n >> 1) & 1;
18364 flags.reply_key_replaced = (n >> 2) & 1;
18365 flags.kdc_verfied = (n >> 3) & 1;
18366 return flags;
18367}
18368
18369static struct units KDCFastFlags_units[] = {
18370 {"kdc_verfied", 1U << 3},
18371 {"reply_key_replaced", 1U << 2},
18372 {"reply_key_used", 1U << 1},
18373 {"use_reply_key", 1U << 0},
18374 {NULL, 0}
18375};
18376
18377const struct units * asn1_KDCFastFlags_units(void){
18378return KDCFastFlags_units;
18379}
18380
18381int ASN1CALL
18382encode_KDCFastState(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDCFastState *data, size_t *size)
18383{
18384size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18385size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18386int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18387
18388/* expected-pa-types */
18389if((data)->expected_pa_types) {
18390size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18391ret = 0;
18392for(i = (int)((data)->expected_pa_types)->len - 1; i >= 0; --i) {
18393size_t expected_pa_types_tag_tag_for_oldret = ret;
18394ret = 0;
18395e = encode_PADATA_TYPE(p, len, &((data)->expected_pa_types)->val[i], &l);
18396if (e) return e;
18397p -= l; len -= l; ret += l;
18398
18399ret += expected_pa_types_tag_tag_for_oldret;
18400}
18401e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
18402if (e) return e;
18403p -= l; len -= l; ret += l;
18404
18405e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
18406if (e) return e;
18407p -= l; len -= l; ret += l;
18408
18409ret += Top_tag_oldret;
18410}
18411/* fast-state */
18412{
18413size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18414ret = 0;
18415e = encode_METHOD_DATA(p, len, &(data)->fast_state, &l);
18416if (e) return e;
18417p -= l; len -= l; ret += l;
18418
18419e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
18420if (e) return e;
18421p -= l; len -= l; ret += l;
18422
18423ret += Top_tag_oldret;
18424}
18425/* expiration */
18426{
18427size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18428ret = 0;
18429e = der_put_generalized_time(p, len, &(data)->expiration, &l);
18430if (e) return e;
18431p -= l; len -= l; ret += l;
18432
18433e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, &l);
18434if (e) return e;
18435p -= l; len -= l; ret += l;
18436
18437e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
18438if (e) return e;
18439p -= l; len -= l; ret += l;
18440
18441ret += Top_tag_oldret;
18442}
18443/* flags */
18444{
18445size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18446ret = 0;
18447e = encode_KDCFastFlags(p, len, &(data)->flags, &l);
18448if (e) return e;
18449p -= l; len -= l; ret += l;
18450
18451e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
18452if (e) return e;
18453p -= l; len -= l; ret += l;
18454
18455ret += Top_tag_oldret;
18456}
18457e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
18458if (e) return e;
18459p -= l; len -= l; ret += l;
18460
18461*size = ret;
18462return 0;
18463}
18464
18465int ASN1CALL
18466decode_KDCFastState(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDCFastState *data, size_t *size)
18467{
18468size_t ret = 0;
18469size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18470int e HEIMDAL_UNUSED_ATTRIBUTE;
18471
18472memset(data, 0, sizeof(*data));
18473{
18474size_t Top_datalen, Top_oldlen;
18475Der_type Top_type;
18476e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
18477if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
18478if(e) goto fail;
18479p += l; len -= l; ret += l;
18480Top_oldlen = len;
18481if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18482len = Top_datalen;
18483{
18484size_t flags_datalen, flags_oldlen;
18485Der_type flags_type;
18486e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 0, &flags_datalen, &l);
18487if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
18488if(e) goto fail;
18489p += l; len -= l; ret += l;
18490flags_oldlen = len;
18491if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18492len = flags_datalen;
18493e = decode_KDCFastFlags(p, len, &(data)->flags, &l);
18494if(e) goto fail;
18495p += l; len -= l; ret += l;
18496len = flags_oldlen - flags_datalen;
18497}
18498{
18499size_t expiration_datalen, expiration_oldlen;
18500Der_type expiration_type;
18501e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &expiration_type, 1, &expiration_datalen, &l);
18502if (e == 0 && expiration_type != CONS) { e = ASN1_BAD_ID; }
18503if(e) goto fail;
18504p += l; len -= l; ret += l;
18505expiration_oldlen = len;
18506if (expiration_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18507len = expiration_datalen;
18508{
18509size_t expiration_Tag_datalen, expiration_Tag_oldlen;
18510Der_type expiration_Tag_type;
18511e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &expiration_Tag_type, UT_GeneralizedTime, &expiration_Tag_datalen, &l);
18512if (e == 0 && expiration_Tag_type != PRIM) { e = ASN1_BAD_ID; }
18513if(e) goto fail;
18514p += l; len -= l; ret += l;
18515expiration_Tag_oldlen = len;
18516if (expiration_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18517len = expiration_Tag_datalen;
18518e = der_get_generalized_time(p, len, &(data)->expiration, &l);
18519if(e) goto fail;
18520p += l; len -= l; ret += l;
18521len = expiration_Tag_oldlen - expiration_Tag_datalen;
18522}
18523len = expiration_oldlen - expiration_datalen;
18524}
18525{
18526size_t fast_state_datalen, fast_state_oldlen;
18527Der_type fast_state_type;
18528e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &fast_state_type, 2, &fast_state_datalen, &l);
18529if (e == 0 && fast_state_type != CONS) { e = ASN1_BAD_ID; }
18530if(e) goto fail;
18531p += l; len -= l; ret += l;
18532fast_state_oldlen = len;
18533if (fast_state_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18534len = fast_state_datalen;
18535e = decode_METHOD_DATA(p, len, &(data)->fast_state, &l);
18536if(e) goto fail;
18537p += l; len -= l; ret += l;
18538len = fast_state_oldlen - fast_state_datalen;
18539}
18540{
18541size_t expected_pa_types_datalen, expected_pa_types_oldlen;
18542Der_type expected_pa_types_type;
18543e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &expected_pa_types_type, 3, &expected_pa_types_datalen, &l);
18544if (e == 0 && expected_pa_types_type != CONS) { e = ASN1_BAD_ID; }
18545if(e) {
18546(data)->expected_pa_types = NULL;
18547} else {
18548(data)->expected_pa_types = calloc(1, sizeof(*(data)->expected_pa_types));
18549if ((data)->expected_pa_types == NULL) { e = ENOMEM; goto fail; }
18550p += l; len -= l; ret += l;
18551expected_pa_types_oldlen = len;
18552if (expected_pa_types_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18553len = expected_pa_types_datalen;
18554{
18555size_t expected_pa_types_Tag_datalen, expected_pa_types_Tag_oldlen;
18556Der_type expected_pa_types_Tag_type;
18557e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &expected_pa_types_Tag_type, UT_Sequence, &expected_pa_types_Tag_datalen, &l);
18558if (e == 0 && expected_pa_types_Tag_type != CONS) { e = ASN1_BAD_ID; }
18559if(e) goto fail;
18560p += l; len -= l; ret += l;
18561expected_pa_types_Tag_oldlen = len;
18562if (expected_pa_types_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18563len = expected_pa_types_Tag_datalen;
18564{
18565size_t expected_pa_types_Tag_Tag_origlen = len;
18566size_t expected_pa_types_Tag_Tag_oldret = ret;
18567size_t expected_pa_types_Tag_Tag_olen = 0;
18568void *expected_pa_types_Tag_Tag_tmp;
18569ret = 0;
18570((data)->expected_pa_types)->len = 0;
18571((data)->expected_pa_types)->val = NULL;
18572while(ret < expected_pa_types_Tag_Tag_origlen) {
18573size_t expected_pa_types_Tag_Tag_nlen = expected_pa_types_Tag_Tag_olen + sizeof(*(((data)->expected_pa_types)->val));
18574if (expected_pa_types_Tag_Tag_olen > expected_pa_types_Tag_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
18575expected_pa_types_Tag_Tag_olen = expected_pa_types_Tag_Tag_nlen;
18576expected_pa_types_Tag_Tag_tmp = realloc(((data)->expected_pa_types)->val, expected_pa_types_Tag_Tag_olen);
18577if (expected_pa_types_Tag_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
18578((data)->expected_pa_types)->val = expected_pa_types_Tag_Tag_tmp;
18579e = decode_PADATA_TYPE(p, len, &((data)->expected_pa_types)->val[((data)->expected_pa_types)->len], &l);
18580if(e) goto fail;
18581p += l; len -= l; ret += l;
18582((data)->expected_pa_types)->len++;
18583len = expected_pa_types_Tag_Tag_origlen - ret;
18584}
18585ret += expected_pa_types_Tag_Tag_oldret;
18586}
18587len = expected_pa_types_Tag_oldlen - expected_pa_types_Tag_datalen;
18588}
18589len = expected_pa_types_oldlen - expected_pa_types_datalen;
18590}
18591}
18592len = Top_oldlen - Top_datalen;
18593}
18594if(size) *size = ret;
18595return 0;
18596fail:
18597free_KDCFastState(data);
18598return e;
18599}
18600
18601void ASN1CALL
18602free_KDCFastState(KDCFastState *data)
18603{
18604free_KDCFastFlags(&(data)->flags);
18605free_METHOD_DATA(&(data)->fast_state);
18606if((data)->expected_pa_types) {
18607while(((data)->expected_pa_types)->len){
18608free_PADATA_TYPE(&((data)->expected_pa_types)->val[((data)->expected_pa_types)->len-1]);
18609((data)->expected_pa_types)->len--;
18610}
18611free(((data)->expected_pa_types)->val);
18612((data)->expected_pa_types)->val = NULL;
18613free((data)->expected_pa_types);
18614(data)->expected_pa_types = NULL;
18615}
18616}
18617
18618size_t ASN1CALL
18619length_KDCFastState(const KDCFastState *data)
18620{
18621size_t ret = 0;
18622{
18623size_t Top_tag_oldret = ret;
18624ret = 0;
18625ret += length_KDCFastFlags(&(data)->flags);
18626ret += 1 + der_length_len (ret);
18627ret += Top_tag_oldret;
18628}
18629{
18630size_t Top_tag_oldret = ret;
18631ret = 0;
18632ret += der_length_generalized_time(&(data)->expiration);
18633ret += 1 + der_length_len (ret);
18634ret += 1 + der_length_len (ret);
18635ret += Top_tag_oldret;
18636}
18637{
18638size_t Top_tag_oldret = ret;
18639ret = 0;
18640ret += length_METHOD_DATA(&(data)->fast_state);
18641ret += 1 + der_length_len (ret);
18642ret += Top_tag_oldret;
18643}
18644if((data)->expected_pa_types){
18645size_t Top_tag_oldret = ret;
18646ret = 0;
18647{
18648size_t expected_pa_types_tag_tag_oldret = ret;
18649unsigned int n_expected_pa_types_tag_tag;
18650ret = 0;
18651for(n_expected_pa_types_tag_tag = ((data)->expected_pa_types)->len; n_expected_pa_types_tag_tag > 0; --n_expected_pa_types_tag_tag){
18652size_t expected_pa_types_tag_tag_for_oldret = ret;
18653ret = 0;
18654ret += length_PADATA_TYPE(&((data)->expected_pa_types)->val[n_expected_pa_types_tag_tag - 1]);
18655ret += expected_pa_types_tag_tag_for_oldret;
18656}
18657ret += expected_pa_types_tag_tag_oldret;
18658}
18659ret += 1 + der_length_len (ret);
18660ret += 1 + der_length_len (ret);
18661ret += Top_tag_oldret;
18662}
18663ret += 1 + der_length_len (ret);
18664return ret;
18665}
18666
18667int ASN1CALL
18668copy_KDCFastState(const KDCFastState *from, KDCFastState *to)
18669{
18670memset(to, 0, sizeof(*to));
18671if(copy_KDCFastFlags(&(from)->flags, &(to)->flags)) goto fail;
18672*(&(to)->expiration) = *(&(from)->expiration);
18673if(copy_METHOD_DATA(&(from)->fast_state, &(to)->fast_state)) goto fail;
18674if((from)->expected_pa_types) {
18675(to)->expected_pa_types = malloc(sizeof(*(to)->expected_pa_types));
18676if((to)->expected_pa_types == NULL) goto fail;
18677if((((to)->expected_pa_types)->val = malloc(((from)->expected_pa_types)->len * sizeof(*((to)->expected_pa_types)->val))) == NULL && ((from)->expected_pa_types)->len != 0)
18678goto fail;
18679for(((to)->expected_pa_types)->len = 0; ((to)->expected_pa_types)->len < ((from)->expected_pa_types)->len; ((to)->expected_pa_types)->len++){
18680if(copy_PADATA_TYPE(&((from)->expected_pa_types)->val[((to)->expected_pa_types)->len], &((to)->expected_pa_types)->val[((to)->expected_pa_types)->len])) goto fail;
18681}
18682}else
18683(to)->expected_pa_types = NULL;
18684return 0;
18685fail:
18686free_KDCFastState(to);
18687return ENOMEM;
18688}
18689
18690int ASN1CALL
18691encode_KDCFastCookie(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDCFastCookie *data, size_t *size)
18692{
18693size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18694size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18695int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18696
18697/* cookie */
18698{
18699size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18700ret = 0;
18701e = encode_EncryptedData(p, len, &(data)->cookie, &l);
18702if (e) return e;
18703p -= l; len -= l; ret += l;
18704
18705e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
18706if (e) return e;
18707p -= l; len -= l; ret += l;
18708
18709ret += Top_tag_oldret;
18710}
18711/* version */
18712{
18713size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18714ret = 0;
18715e = der_put_utf8string(p, len, &(data)->version, &l);
18716if (e) return e;
18717p -= l; len -= l; ret += l;
18718
18719e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
18720if (e) return e;
18721p -= l; len -= l; ret += l;
18722
18723e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
18724if (e) return e;
18725p -= l; len -= l; ret += l;
18726
18727ret += Top_tag_oldret;
18728}
18729e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
18730if (e) return e;
18731p -= l; len -= l; ret += l;
18732
18733*size = ret;
18734return 0;
18735}
18736
18737int ASN1CALL
18738decode_KDCFastCookie(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDCFastCookie *data, size_t *size)
18739{
18740size_t ret = 0;
18741size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18742int e HEIMDAL_UNUSED_ATTRIBUTE;
18743
18744memset(data, 0, sizeof(*data));
18745{
18746size_t Top_datalen, Top_oldlen;
18747Der_type Top_type;
18748e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
18749if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
18750if(e) goto fail;
18751p += l; len -= l; ret += l;
18752Top_oldlen = len;
18753if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18754len = Top_datalen;
18755{
18756size_t version_datalen, version_oldlen;
18757Der_type version_type;
18758e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &version_type, 0, &version_datalen, &l);
18759if (e == 0 && version_type != CONS) { e = ASN1_BAD_ID; }
18760if(e) goto fail;
18761p += l; len -= l; ret += l;
18762version_oldlen = len;
18763if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18764len = version_datalen;
18765{
18766size_t version_Tag_datalen, version_Tag_oldlen;
18767Der_type version_Tag_type;
18768e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &version_Tag_type, UT_UTF8String, &version_Tag_datalen, &l);
18769if (e == 0 && version_Tag_type != PRIM) { e = ASN1_BAD_ID; }
18770if(e) goto fail;
18771p += l; len -= l; ret += l;
18772version_Tag_oldlen = len;
18773if (version_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18774len = version_Tag_datalen;
18775e = der_get_utf8string(p, len, &(data)->version, &l);
18776if(e) goto fail;
18777p += l; len -= l; ret += l;
18778len = version_Tag_oldlen - version_Tag_datalen;
18779}
18780len = version_oldlen - version_datalen;
18781}
18782{
18783size_t cookie_datalen, cookie_oldlen;
18784Der_type cookie_type;
18785e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cookie_type, 1, &cookie_datalen, &l);
18786if (e == 0 && cookie_type != CONS) { e = ASN1_BAD_ID; }
18787if(e) goto fail;
18788p += l; len -= l; ret += l;
18789cookie_oldlen = len;
18790if (cookie_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18791len = cookie_datalen;
18792e = decode_EncryptedData(p, len, &(data)->cookie, &l);
18793if(e) goto fail;
18794p += l; len -= l; ret += l;
18795len = cookie_oldlen - cookie_datalen;
18796}
18797len = Top_oldlen - Top_datalen;
18798}
18799if(size) *size = ret;
18800return 0;
18801fail:
18802free_KDCFastCookie(data);
18803return e;
18804}
18805
18806void ASN1CALL
18807free_KDCFastCookie(KDCFastCookie *data)
18808{
18809der_free_utf8string(&(data)->version);
18810free_EncryptedData(&(data)->cookie);
18811}
18812
18813size_t ASN1CALL
18814length_KDCFastCookie(const KDCFastCookie *data)
18815{
18816size_t ret = 0;
18817{
18818size_t Top_tag_oldret = ret;
18819ret = 0;
18820ret += der_length_utf8string(&(data)->version);
18821ret += 1 + der_length_len (ret);
18822ret += 1 + der_length_len (ret);
18823ret += Top_tag_oldret;
18824}
18825{
18826size_t Top_tag_oldret = ret;
18827ret = 0;
18828ret += length_EncryptedData(&(data)->cookie);
18829ret += 1 + der_length_len (ret);
18830ret += Top_tag_oldret;
18831}
18832ret += 1 + der_length_len (ret);
18833return ret;
18834}
18835
18836int ASN1CALL
18837copy_KDCFastCookie(const KDCFastCookie *from, KDCFastCookie *to)
18838{
18839memset(to, 0, sizeof(*to));
18840if(der_copy_utf8string(&(from)->version, &(to)->version)) goto fail;
18841if(copy_EncryptedData(&(from)->cookie, &(to)->cookie)) goto fail;
18842return 0;
18843fail:
18844free_KDCFastCookie(to);
18845return ENOMEM;
18846}
18847
18848int ASN1CALL
18849encode_KDC_PROXY_MESSAGE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KDC_PROXY_MESSAGE *data, size_t *size)
18850{
18851size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
18852size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18853int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
18854
18855/* dclocator-hint */
18856if((data)->dclocator_hint) {
18857size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18858ret = 0;
18859e = der_put_heim_integer(p, len, (data)->dclocator_hint, &l);
18860if (e) return e;
18861p -= l; len -= l; ret += l;
18862
18863e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
18864if (e) return e;
18865p -= l; len -= l; ret += l;
18866
18867e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
18868if (e) return e;
18869p -= l; len -= l; ret += l;
18870
18871ret += Top_tag_oldret;
18872}
18873/* target-domain */
18874if((data)->target_domain) {
18875size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18876ret = 0;
18877e = encode_Realm(p, len, (data)->target_domain, &l);
18878if (e) return e;
18879p -= l; len -= l; ret += l;
18880
18881e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
18882if (e) return e;
18883p -= l; len -= l; ret += l;
18884
18885ret += Top_tag_oldret;
18886}
18887/* kerb-message */
18888{
18889size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
18890ret = 0;
18891e = der_put_octet_string(p, len, &(data)->kerb_message, &l);
18892if (e) return e;
18893p -= l; len -= l; ret += l;
18894
18895e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
18896if (e) return e;
18897p -= l; len -= l; ret += l;
18898
18899e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
18900if (e) return e;
18901p -= l; len -= l; ret += l;
18902
18903ret += Top_tag_oldret;
18904}
18905e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
18906if (e) return e;
18907p -= l; len -= l; ret += l;
18908
18909*size = ret;
18910return 0;
18911}
18912
18913int ASN1CALL
18914decode_KDC_PROXY_MESSAGE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDC_PROXY_MESSAGE *data, size_t *size)
18915{
18916size_t ret = 0;
18917size_t l HEIMDAL_UNUSED_ATTRIBUTE;
18918int e HEIMDAL_UNUSED_ATTRIBUTE;
18919
18920memset(data, 0, sizeof(*data));
18921{
18922size_t Top_datalen, Top_oldlen;
18923Der_type Top_type;
18924e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
18925if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
18926if(e) goto fail;
18927p += l; len -= l; ret += l;
18928Top_oldlen = len;
18929if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18930len = Top_datalen;
18931{
18932size_t kerb_message_datalen, kerb_message_oldlen;
18933Der_type kerb_message_type;
18934e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &kerb_message_type, 0, &kerb_message_datalen, &l);
18935if (e == 0 && kerb_message_type != CONS) { e = ASN1_BAD_ID; }
18936if(e) goto fail;
18937p += l; len -= l; ret += l;
18938kerb_message_oldlen = len;
18939if (kerb_message_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18940len = kerb_message_datalen;
18941{
18942size_t kerb_message_Tag_datalen, kerb_message_Tag_oldlen;
18943Der_type kerb_message_Tag_type;
18944e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &kerb_message_Tag_type, UT_OctetString, &kerb_message_Tag_datalen, &l);
18945if (e == 0 && kerb_message_Tag_type != PRIM) { e = ASN1_BAD_ID; }
18946if(e) goto fail;
18947p += l; len -= l; ret += l;
18948kerb_message_Tag_oldlen = len;
18949if (kerb_message_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18950len = kerb_message_Tag_datalen;
18951e = der_get_octet_string(p, len, &(data)->kerb_message, &l);
18952if(e) goto fail;
18953p += l; len -= l; ret += l;
18954len = kerb_message_Tag_oldlen - kerb_message_Tag_datalen;
18955}
18956len = kerb_message_oldlen - kerb_message_datalen;
18957}
18958{
18959size_t target_domain_datalen, target_domain_oldlen;
18960Der_type target_domain_type;
18961e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &target_domain_type, 1, &target_domain_datalen, &l);
18962if (e == 0 && target_domain_type != CONS) { e = ASN1_BAD_ID; }
18963if(e) {
18964(data)->target_domain = NULL;
18965} else {
18966(data)->target_domain = calloc(1, sizeof(*(data)->target_domain));
18967if ((data)->target_domain == NULL) { e = ENOMEM; goto fail; }
18968p += l; len -= l; ret += l;
18969target_domain_oldlen = len;
18970if (target_domain_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18971len = target_domain_datalen;
18972e = decode_Realm(p, len, (data)->target_domain, &l);
18973if(e) goto fail;
18974p += l; len -= l; ret += l;
18975len = target_domain_oldlen - target_domain_datalen;
18976}
18977}
18978{
18979size_t dclocator_hint_datalen, dclocator_hint_oldlen;
18980Der_type dclocator_hint_type;
18981e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &dclocator_hint_type, 2, &dclocator_hint_datalen, &l);
18982if (e == 0 && dclocator_hint_type != CONS) { e = ASN1_BAD_ID; }
18983if(e) {
18984(data)->dclocator_hint = NULL;
18985} else {
18986(data)->dclocator_hint = calloc(1, sizeof(*(data)->dclocator_hint));
18987if ((data)->dclocator_hint == NULL) { e = ENOMEM; goto fail; }
18988p += l; len -= l; ret += l;
18989dclocator_hint_oldlen = len;
18990if (dclocator_hint_datalen > len) { e = ASN1_OVERRUN; goto fail; }
18991len = dclocator_hint_datalen;
18992{
18993size_t dclocator_hint_Tag_datalen, dclocator_hint_Tag_oldlen;
18994Der_type dclocator_hint_Tag_type;
18995e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &dclocator_hint_Tag_type, UT_Integer, &dclocator_hint_Tag_datalen, &l);
18996if (e == 0 && dclocator_hint_Tag_type != PRIM) { e = ASN1_BAD_ID; }
18997if(e) goto fail;
18998p += l; len -= l; ret += l;
18999dclocator_hint_Tag_oldlen = len;
19000if (dclocator_hint_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19001len = dclocator_hint_Tag_datalen;
19002e = der_get_heim_integer(p, len, (data)->dclocator_hint, &l);
19003if(e) goto fail;
19004p += l; len -= l; ret += l;
19005len = dclocator_hint_Tag_oldlen - dclocator_hint_Tag_datalen;
19006}
19007len = dclocator_hint_oldlen - dclocator_hint_datalen;
19008}
19009}
19010len = Top_oldlen - Top_datalen;
19011}
19012if(size) *size = ret;
19013return 0;
19014fail:
19015free_KDC_PROXY_MESSAGE(data);
19016return e;
19017}
19018
19019void ASN1CALL
19020free_KDC_PROXY_MESSAGE(KDC_PROXY_MESSAGE *data)
19021{
19022der_free_octet_string(&(data)->kerb_message);
19023if((data)->target_domain) {
19024free_Realm((data)->target_domain);
19025free((data)->target_domain);
19026(data)->target_domain = NULL;
19027}
19028if((data)->dclocator_hint) {
19029der_free_heim_integer((data)->dclocator_hint);
19030free((data)->dclocator_hint);
19031(data)->dclocator_hint = NULL;
19032}
19033}
19034
19035size_t ASN1CALL
19036length_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *data)
19037{
19038size_t ret = 0;
19039{
19040size_t Top_tag_oldret = ret;
19041ret = 0;
19042ret += der_length_octet_string(&(data)->kerb_message);
19043ret += 1 + der_length_len (ret);
19044ret += 1 + der_length_len (ret);
19045ret += Top_tag_oldret;
19046}
19047if((data)->target_domain){
19048size_t Top_tag_oldret = ret;
19049ret = 0;
19050ret += length_Realm((data)->target_domain);
19051ret += 1 + der_length_len (ret);
19052ret += Top_tag_oldret;
19053}
19054if((data)->dclocator_hint){
19055size_t Top_tag_oldret = ret;
19056ret = 0;
19057ret += der_length_heim_integer((data)->dclocator_hint);
19058ret += 1 + der_length_len (ret);
19059ret += 1 + der_length_len (ret);
19060ret += Top_tag_oldret;
19061}
19062ret += 1 + der_length_len (ret);
19063return ret;
19064}
19065
19066int ASN1CALL
19067copy_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *from, KDC_PROXY_MESSAGE *to)
19068{
19069memset(to, 0, sizeof(*to));
19070if(der_copy_octet_string(&(from)->kerb_message, &(to)->kerb_message)) goto fail;
19071if((from)->target_domain) {
19072(to)->target_domain = malloc(sizeof(*(to)->target_domain));
19073if((to)->target_domain == NULL) goto fail;
19074if(copy_Realm((from)->target_domain, (to)->target_domain)) goto fail;
19075}else
19076(to)->target_domain = NULL;
19077if((from)->dclocator_hint) {
19078(to)->dclocator_hint = malloc(sizeof(*(to)->dclocator_hint));
19079if((to)->dclocator_hint == NULL) goto fail;
19080if(der_copy_heim_integer((from)->dclocator_hint, (to)->dclocator_hint)) goto fail;
19081}else
19082(to)->dclocator_hint = NULL;
19083return 0;
19084fail:
19085free_KDC_PROXY_MESSAGE(to);
19086return ENOMEM;
19087}
19088
19089int ASN1CALL
19090encode_KERB_TIMES(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KERB_TIMES *data, size_t *size)
19091{
19092size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
19093size_t l HEIMDAL_UNUSED_ATTRIBUTE;
19094int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
19095
19096/* renew_till */
19097{
19098size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19099ret = 0;
19100e = encode_KerberosTime(p, len, &(data)->renew_till, &l);
19101if (e) return e;
19102p -= l; len -= l; ret += l;
19103
19104e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
19105if (e) return e;
19106p -= l; len -= l; ret += l;
19107
19108ret += Top_tag_oldret;
19109}
19110/* endtime */
19111{
19112size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19113ret = 0;
19114e = encode_KerberosTime(p, len, &(data)->endtime, &l);
19115if (e) return e;
19116p -= l; len -= l; ret += l;
19117
19118e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
19119if (e) return e;
19120p -= l; len -= l; ret += l;
19121
19122ret += Top_tag_oldret;
19123}
19124/* starttime */
19125{
19126size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19127ret = 0;
19128e = encode_KerberosTime(p, len, &(data)->starttime, &l);
19129if (e) return e;
19130p -= l; len -= l; ret += l;
19131
19132e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
19133if (e) return e;
19134p -= l; len -= l; ret += l;
19135
19136ret += Top_tag_oldret;
19137}
19138/* authtime */
19139{
19140size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19141ret = 0;
19142e = encode_KerberosTime(p, len, &(data)->authtime, &l);
19143if (e) return e;
19144p -= l; len -= l; ret += l;
19145
19146e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
19147if (e) return e;
19148p -= l; len -= l; ret += l;
19149
19150ret += Top_tag_oldret;
19151}
19152e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
19153if (e) return e;
19154p -= l; len -= l; ret += l;
19155
19156*size = ret;
19157return 0;
19158}
19159
19160int ASN1CALL
19161decode_KERB_TIMES(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KERB_TIMES *data, size_t *size)
19162{
19163size_t ret = 0;
19164size_t l HEIMDAL_UNUSED_ATTRIBUTE;
19165int e HEIMDAL_UNUSED_ATTRIBUTE;
19166
19167memset(data, 0, sizeof(*data));
19168{
19169size_t Top_datalen, Top_oldlen;
19170Der_type Top_type;
19171e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
19172if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
19173if(e) goto fail;
19174p += l; len -= l; ret += l;
19175Top_oldlen = len;
19176if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19177len = Top_datalen;
19178{
19179size_t authtime_datalen, authtime_oldlen;
19180Der_type authtime_type;
19181e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authtime_type, 0, &authtime_datalen, &l);
19182if (e == 0 && authtime_type != CONS) { e = ASN1_BAD_ID; }
19183if(e) goto fail;
19184p += l; len -= l; ret += l;
19185authtime_oldlen = len;
19186if (authtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19187len = authtime_datalen;
19188e = decode_KerberosTime(p, len, &(data)->authtime, &l);
19189if(e) goto fail;
19190p += l; len -= l; ret += l;
19191len = authtime_oldlen - authtime_datalen;
19192}
19193{
19194size_t starttime_datalen, starttime_oldlen;
19195Der_type starttime_type;
19196e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &starttime_type, 1, &starttime_datalen, &l);
19197if (e == 0 && starttime_type != CONS) { e = ASN1_BAD_ID; }
19198if(e) goto fail;
19199p += l; len -= l; ret += l;
19200starttime_oldlen = len;
19201if (starttime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19202len = starttime_datalen;
19203e = decode_KerberosTime(p, len, &(data)->starttime, &l);
19204if(e) goto fail;
19205p += l; len -= l; ret += l;
19206len = starttime_oldlen - starttime_datalen;
19207}
19208{
19209size_t endtime_datalen, endtime_oldlen;
19210Der_type endtime_type;
19211e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &endtime_type, 2, &endtime_datalen, &l);
19212if (e == 0 && endtime_type != CONS) { e = ASN1_BAD_ID; }
19213if(e) goto fail;
19214p += l; len -= l; ret += l;
19215endtime_oldlen = len;
19216if (endtime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19217len = endtime_datalen;
19218e = decode_KerberosTime(p, len, &(data)->endtime, &l);
19219if(e) goto fail;
19220p += l; len -= l; ret += l;
19221len = endtime_oldlen - endtime_datalen;
19222}
19223{
19224size_t renew_till_datalen, renew_till_oldlen;
19225Der_type renew_till_type;
19226e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &renew_till_type, 3, &renew_till_datalen, &l);
19227if (e == 0 && renew_till_type != CONS) { e = ASN1_BAD_ID; }
19228if(e) goto fail;
19229p += l; len -= l; ret += l;
19230renew_till_oldlen = len;
19231if (renew_till_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19232len = renew_till_datalen;
19233e = decode_KerberosTime(p, len, &(data)->renew_till, &l);
19234if(e) goto fail;
19235p += l; len -= l; ret += l;
19236len = renew_till_oldlen - renew_till_datalen;
19237}
19238len = Top_oldlen - Top_datalen;
19239}
19240if(size) *size = ret;
19241return 0;
19242fail:
19243free_KERB_TIMES(data);
19244return e;
19245}
19246
19247void ASN1CALL
19248free_KERB_TIMES(KERB_TIMES *data)
19249{
19250free_KerberosTime(&(data)->authtime);
19251free_KerberosTime(&(data)->starttime);
19252free_KerberosTime(&(data)->endtime);
19253free_KerberosTime(&(data)->renew_till);
19254}
19255
19256size_t ASN1CALL
19257length_KERB_TIMES(const KERB_TIMES *data)
19258{
19259size_t ret = 0;
19260{
19261size_t Top_tag_oldret = ret;
19262ret = 0;
19263ret += length_KerberosTime(&(data)->authtime);
19264ret += 1 + der_length_len (ret);
19265ret += Top_tag_oldret;
19266}
19267{
19268size_t Top_tag_oldret = ret;
19269ret = 0;
19270ret += length_KerberosTime(&(data)->starttime);
19271ret += 1 + der_length_len (ret);
19272ret += Top_tag_oldret;
19273}
19274{
19275size_t Top_tag_oldret = ret;
19276ret = 0;
19277ret += length_KerberosTime(&(data)->endtime);
19278ret += 1 + der_length_len (ret);
19279ret += Top_tag_oldret;
19280}
19281{
19282size_t Top_tag_oldret = ret;
19283ret = 0;
19284ret += length_KerberosTime(&(data)->renew_till);
19285ret += 1 + der_length_len (ret);
19286ret += Top_tag_oldret;
19287}
19288ret += 1 + der_length_len (ret);
19289return ret;
19290}
19291
19292int ASN1CALL
19293copy_KERB_TIMES(const KERB_TIMES *from, KERB_TIMES *to)
19294{
19295memset(to, 0, sizeof(*to));
19296if(copy_KerberosTime(&(from)->authtime, &(to)->authtime)) goto fail;
19297if(copy_KerberosTime(&(from)->starttime, &(to)->starttime)) goto fail;
19298if(copy_KerberosTime(&(from)->endtime, &(to)->endtime)) goto fail;
19299if(copy_KerberosTime(&(from)->renew_till, &(to)->renew_till)) goto fail;
19300return 0;
19301fail:
19302free_KERB_TIMES(to);
19303return ENOMEM;
19304}
19305
19306int ASN1CALL
19307encode_KERB_CRED(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KERB_CRED *data, size_t *size)
19308{
19309size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
19310size_t l HEIMDAL_UNUSED_ATTRIBUTE;
19311int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
19312
19313/* flags */
19314{
19315size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19316ret = 0;
19317e = encode_TicketFlags(p, len, &(data)->flags, &l);
19318if (e) return e;
19319p -= l; len -= l; ret += l;
19320
19321e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
19322if (e) return e;
19323p -= l; len -= l; ret += l;
19324
19325ret += Top_tag_oldret;
19326}
19327/* addresses */
19328{
19329size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19330ret = 0;
19331e = encode_HostAddresses(p, len, &(data)->addresses, &l);
19332if (e) return e;
19333p -= l; len -= l; ret += l;
19334
19335e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
19336if (e) return e;
19337p -= l; len -= l; ret += l;
19338
19339ret += Top_tag_oldret;
19340}
19341/* authdata */
19342{
19343size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19344ret = 0;
19345e = der_put_octet_string(p, len, &(data)->authdata, &l);
19346if (e) return e;
19347p -= l; len -= l; ret += l;
19348
19349e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
19350if (e) return e;
19351p -= l; len -= l; ret += l;
19352
19353e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
19354if (e) return e;
19355p -= l; len -= l; ret += l;
19356
19357ret += Top_tag_oldret;
19358}
19359/* ticket */
19360{
19361size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19362ret = 0;
19363e = der_put_octet_string(p, len, &(data)->ticket, &l);
19364if (e) return e;
19365p -= l; len -= l; ret += l;
19366
19367e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
19368if (e) return e;
19369p -= l; len -= l; ret += l;
19370
19371e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
19372if (e) return e;
19373p -= l; len -= l; ret += l;
19374
19375ret += Top_tag_oldret;
19376}
19377/* times */
19378{
19379size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19380ret = 0;
19381e = encode_KERB_TIMES(p, len, &(data)->times, &l);
19382if (e) return e;
19383p -= l; len -= l; ret += l;
19384
19385e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
19386if (e) return e;
19387p -= l; len -= l; ret += l;
19388
19389ret += Top_tag_oldret;
19390}
19391/* keyblock */
19392{
19393size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19394ret = 0;
19395e = encode_EncryptionKey(p, len, &(data)->keyblock, &l);
19396if (e) return e;
19397p -= l; len -= l; ret += l;
19398
19399e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
19400if (e) return e;
19401p -= l; len -= l; ret += l;
19402
19403ret += Top_tag_oldret;
19404}
19405/* server */
19406{
19407size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19408ret = 0;
19409e = encode_Principal(p, len, &(data)->server, &l);
19410if (e) return e;
19411p -= l; len -= l; ret += l;
19412
19413e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
19414if (e) return e;
19415p -= l; len -= l; ret += l;
19416
19417ret += Top_tag_oldret;
19418}
19419/* client */
19420{
19421size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19422ret = 0;
19423e = encode_Principal(p, len, &(data)->client, &l);
19424if (e) return e;
19425p -= l; len -= l; ret += l;
19426
19427e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
19428if (e) return e;
19429p -= l; len -= l; ret += l;
19430
19431ret += Top_tag_oldret;
19432}
19433e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
19434if (e) return e;
19435p -= l; len -= l; ret += l;
19436
19437*size = ret;
19438return 0;
19439}
19440
19441int ASN1CALL
19442decode_KERB_CRED(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KERB_CRED *data, size_t *size)
19443{
19444size_t ret = 0;
19445size_t l HEIMDAL_UNUSED_ATTRIBUTE;
19446int e HEIMDAL_UNUSED_ATTRIBUTE;
19447
19448memset(data, 0, sizeof(*data));
19449{
19450size_t Top_datalen, Top_oldlen;
19451Der_type Top_type;
19452e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
19453if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
19454if(e) goto fail;
19455p += l; len -= l; ret += l;
19456Top_oldlen = len;
19457if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19458len = Top_datalen;
19459{
19460size_t client_datalen, client_oldlen;
19461Der_type client_type;
19462e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &client_type, 0, &client_datalen, &l);
19463if (e == 0 && client_type != CONS) { e = ASN1_BAD_ID; }
19464if(e) goto fail;
19465p += l; len -= l; ret += l;
19466client_oldlen = len;
19467if (client_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19468len = client_datalen;
19469e = decode_Principal(p, len, &(data)->client, &l);
19470if(e) goto fail;
19471p += l; len -= l; ret += l;
19472len = client_oldlen - client_datalen;
19473}
19474{
19475size_t server_datalen, server_oldlen;
19476Der_type server_type;
19477e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &server_type, 1, &server_datalen, &l);
19478if (e == 0 && server_type != CONS) { e = ASN1_BAD_ID; }
19479if(e) goto fail;
19480p += l; len -= l; ret += l;
19481server_oldlen = len;
19482if (server_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19483len = server_datalen;
19484e = decode_Principal(p, len, &(data)->server, &l);
19485if(e) goto fail;
19486p += l; len -= l; ret += l;
19487len = server_oldlen - server_datalen;
19488}
19489{
19490size_t keyblock_datalen, keyblock_oldlen;
19491Der_type keyblock_type;
19492e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keyblock_type, 2, &keyblock_datalen, &l);
19493if (e == 0 && keyblock_type != CONS) { e = ASN1_BAD_ID; }
19494if(e) goto fail;
19495p += l; len -= l; ret += l;
19496keyblock_oldlen = len;
19497if (keyblock_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19498len = keyblock_datalen;
19499e = decode_EncryptionKey(p, len, &(data)->keyblock, &l);
19500if(e) goto fail;
19501p += l; len -= l; ret += l;
19502len = keyblock_oldlen - keyblock_datalen;
19503}
19504{
19505size_t times_datalen, times_oldlen;
19506Der_type times_type;
19507e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &times_type, 3, &times_datalen, &l);
19508if (e == 0 && times_type != CONS) { e = ASN1_BAD_ID; }
19509if(e) goto fail;
19510p += l; len -= l; ret += l;
19511times_oldlen = len;
19512if (times_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19513len = times_datalen;
19514e = decode_KERB_TIMES(p, len, &(data)->times, &l);
19515if(e) goto fail;
19516p += l; len -= l; ret += l;
19517len = times_oldlen - times_datalen;
19518}
19519{
19520size_t ticket_datalen, ticket_oldlen;
19521Der_type ticket_type;
19522e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_type, 4, &ticket_datalen, &l);
19523if (e == 0 && ticket_type != CONS) { e = ASN1_BAD_ID; }
19524if(e) goto fail;
19525p += l; len -= l; ret += l;
19526ticket_oldlen = len;
19527if (ticket_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19528len = ticket_datalen;
19529{
19530size_t ticket_Tag_datalen, ticket_Tag_oldlen;
19531Der_type ticket_Tag_type;
19532e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ticket_Tag_type, UT_OctetString, &ticket_Tag_datalen, &l);
19533if (e == 0 && ticket_Tag_type != PRIM) { e = ASN1_BAD_ID; }
19534if(e) goto fail;
19535p += l; len -= l; ret += l;
19536ticket_Tag_oldlen = len;
19537if (ticket_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19538len = ticket_Tag_datalen;
19539e = der_get_octet_string(p, len, &(data)->ticket, &l);
19540if(e) goto fail;
19541p += l; len -= l; ret += l;
19542len = ticket_Tag_oldlen - ticket_Tag_datalen;
19543}
19544len = ticket_oldlen - ticket_datalen;
19545}
19546{
19547size_t authdata_datalen, authdata_oldlen;
19548Der_type authdata_type;
19549e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authdata_type, 5, &authdata_datalen, &l);
19550if (e == 0 && authdata_type != CONS) { e = ASN1_BAD_ID; }
19551if(e) goto fail;
19552p += l; len -= l; ret += l;
19553authdata_oldlen = len;
19554if (authdata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19555len = authdata_datalen;
19556{
19557size_t authdata_Tag_datalen, authdata_Tag_oldlen;
19558Der_type authdata_Tag_type;
19559e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &authdata_Tag_type, UT_OctetString, &authdata_Tag_datalen, &l);
19560if (e == 0 && authdata_Tag_type != PRIM) { e = ASN1_BAD_ID; }
19561if(e) goto fail;
19562p += l; len -= l; ret += l;
19563authdata_Tag_oldlen = len;
19564if (authdata_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19565len = authdata_Tag_datalen;
19566e = der_get_octet_string(p, len, &(data)->authdata, &l);
19567if(e) goto fail;
19568p += l; len -= l; ret += l;
19569len = authdata_Tag_oldlen - authdata_Tag_datalen;
19570}
19571len = authdata_oldlen - authdata_datalen;
19572}
19573{
19574size_t addresses_datalen, addresses_oldlen;
19575Der_type addresses_type;
19576e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &addresses_type, 6, &addresses_datalen, &l);
19577if (e == 0 && addresses_type != CONS) { e = ASN1_BAD_ID; }
19578if(e) goto fail;
19579p += l; len -= l; ret += l;
19580addresses_oldlen = len;
19581if (addresses_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19582len = addresses_datalen;
19583e = decode_HostAddresses(p, len, &(data)->addresses, &l);
19584if(e) goto fail;
19585p += l; len -= l; ret += l;
19586len = addresses_oldlen - addresses_datalen;
19587}
19588{
19589size_t flags_datalen, flags_oldlen;
19590Der_type flags_type;
19591e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 7, &flags_datalen, &l);
19592if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
19593if(e) goto fail;
19594p += l; len -= l; ret += l;
19595flags_oldlen = len;
19596if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19597len = flags_datalen;
19598e = decode_TicketFlags(p, len, &(data)->flags, &l);
19599if(e) goto fail;
19600p += l; len -= l; ret += l;
19601len = flags_oldlen - flags_datalen;
19602}
19603len = Top_oldlen - Top_datalen;
19604}
19605if(size) *size = ret;
19606return 0;
19607fail:
19608free_KERB_CRED(data);
19609return e;
19610}
19611
19612void ASN1CALL
19613free_KERB_CRED(KERB_CRED *data)
19614{
19615free_Principal(&(data)->client);
19616free_Principal(&(data)->server);
19617free_EncryptionKey(&(data)->keyblock);
19618free_KERB_TIMES(&(data)->times);
19619der_free_octet_string(&(data)->ticket);
19620der_free_octet_string(&(data)->authdata);
19621free_HostAddresses(&(data)->addresses);
19622free_TicketFlags(&(data)->flags);
19623}
19624
19625size_t ASN1CALL
19626length_KERB_CRED(const KERB_CRED *data)
19627{
19628size_t ret = 0;
19629{
19630size_t Top_tag_oldret = ret;
19631ret = 0;
19632ret += length_Principal(&(data)->client);
19633ret += 1 + der_length_len (ret);
19634ret += Top_tag_oldret;
19635}
19636{
19637size_t Top_tag_oldret = ret;
19638ret = 0;
19639ret += length_Principal(&(data)->server);
19640ret += 1 + der_length_len (ret);
19641ret += Top_tag_oldret;
19642}
19643{
19644size_t Top_tag_oldret = ret;
19645ret = 0;
19646ret += length_EncryptionKey(&(data)->keyblock);
19647ret += 1 + der_length_len (ret);
19648ret += Top_tag_oldret;
19649}
19650{
19651size_t Top_tag_oldret = ret;
19652ret = 0;
19653ret += length_KERB_TIMES(&(data)->times);
19654ret += 1 + der_length_len (ret);
19655ret += Top_tag_oldret;
19656}
19657{
19658size_t Top_tag_oldret = ret;
19659ret = 0;
19660ret += der_length_octet_string(&(data)->ticket);
19661ret += 1 + der_length_len (ret);
19662ret += 1 + der_length_len (ret);
19663ret += Top_tag_oldret;
19664}
19665{
19666size_t Top_tag_oldret = ret;
19667ret = 0;
19668ret += der_length_octet_string(&(data)->authdata);
19669ret += 1 + der_length_len (ret);
19670ret += 1 + der_length_len (ret);
19671ret += Top_tag_oldret;
19672}
19673{
19674size_t Top_tag_oldret = ret;
19675ret = 0;
19676ret += length_HostAddresses(&(data)->addresses);
19677ret += 1 + der_length_len (ret);
19678ret += Top_tag_oldret;
19679}
19680{
19681size_t Top_tag_oldret = ret;
19682ret = 0;
19683ret += length_TicketFlags(&(data)->flags);
19684ret += 1 + der_length_len (ret);
19685ret += Top_tag_oldret;
19686}
19687ret += 1 + der_length_len (ret);
19688return ret;
19689}
19690
19691int ASN1CALL
19692copy_KERB_CRED(const KERB_CRED *from, KERB_CRED *to)
19693{
19694memset(to, 0, sizeof(*to));
19695if(copy_Principal(&(from)->client, &(to)->client)) goto fail;
19696if(copy_Principal(&(from)->server, &(to)->server)) goto fail;
19697if(copy_EncryptionKey(&(from)->keyblock, &(to)->keyblock)) goto fail;
19698if(copy_KERB_TIMES(&(from)->times, &(to)->times)) goto fail;
19699if(der_copy_octet_string(&(from)->ticket, &(to)->ticket)) goto fail;
19700if(der_copy_octet_string(&(from)->authdata, &(to)->authdata)) goto fail;
19701if(copy_HostAddresses(&(from)->addresses, &(to)->addresses)) goto fail;
19702if(copy_TicketFlags(&(from)->flags, &(to)->flags)) goto fail;
19703return 0;
19704fail:
19705free_KERB_CRED(to);
19706return ENOMEM;
19707}
19708
19709int ASN1CALL
19710encode_KERB_TGS_REQ_IN(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KERB_TGS_REQ_IN *data, size_t *size)
19711{
19712size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
19713size_t l HEIMDAL_UNUSED_ATTRIBUTE;
19714int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
19715
19716/* padata */
19717{
19718size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19719ret = 0;
19720e = encode_METHOD_DATA(p, len, &(data)->padata, &l);
19721if (e) return e;
19722p -= l; len -= l; ret += l;
19723
19724e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
19725if (e) return e;
19726p -= l; len -= l; ret += l;
19727
19728ret += Top_tag_oldret;
19729}
19730/* krbtgt */
19731{
19732size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19733ret = 0;
19734e = encode_KERB_CRED(p, len, &(data)->krbtgt, &l);
19735if (e) return e;
19736p -= l; len -= l; ret += l;
19737
19738e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
19739if (e) return e;
19740p -= l; len -= l; ret += l;
19741
19742ret += Top_tag_oldret;
19743}
19744/* in_cred */
19745{
19746size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19747ret = 0;
19748e = encode_KERB_CRED(p, len, &(data)->in_cred, &l);
19749if (e) return e;
19750p -= l; len -= l; ret += l;
19751
19752e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
19753if (e) return e;
19754p -= l; len -= l; ret += l;
19755
19756ret += Top_tag_oldret;
19757}
19758/* ticket */
19759if((data)->ticket) {
19760size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19761ret = 0;
19762e = der_put_octet_string(p, len, (data)->ticket, &l);
19763if (e) return e;
19764p -= l; len -= l; ret += l;
19765
19766e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
19767if (e) return e;
19768p -= l; len -= l; ret += l;
19769
19770e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
19771if (e) return e;
19772p -= l; len -= l; ret += l;
19773
19774ret += Top_tag_oldret;
19775}
19776/* imp */
19777if((data)->imp) {
19778size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19779ret = 0;
19780e = encode_Principal(p, len, (data)->imp, &l);
19781if (e) return e;
19782p -= l; len -= l; ret += l;
19783
19784e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
19785if (e) return e;
19786p -= l; len -= l; ret += l;
19787
19788ret += Top_tag_oldret;
19789}
19790/* flags */
19791{
19792size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19793ret = 0;
19794e = encode_krb5uint32(p, len, &(data)->flags, &l);
19795if (e) return e;
19796p -= l; len -= l; ret += l;
19797
19798e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
19799if (e) return e;
19800p -= l; len -= l; ret += l;
19801
19802ret += Top_tag_oldret;
19803}
19804/* addrs */
19805{
19806size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19807ret = 0;
19808e = encode_HostAddresses(p, len, &(data)->addrs, &l);
19809if (e) return e;
19810p -= l; len -= l; ret += l;
19811
19812e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
19813if (e) return e;
19814p -= l; len -= l; ret += l;
19815
19816ret += Top_tag_oldret;
19817}
19818/* cache */
19819{
19820size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
19821ret = 0;
19822e = der_put_octet_string(p, len, &(data)->cache, &l);
19823if (e) return e;
19824p -= l; len -= l; ret += l;
19825
19826e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
19827if (e) return e;
19828p -= l; len -= l; ret += l;
19829
19830e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
19831if (e) return e;
19832p -= l; len -= l; ret += l;
19833
19834ret += Top_tag_oldret;
19835}
19836e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
19837if (e) return e;
19838p -= l; len -= l; ret += l;
19839
19840*size = ret;
19841return 0;
19842}
19843
19844int ASN1CALL
19845decode_KERB_TGS_REQ_IN(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KERB_TGS_REQ_IN *data, size_t *size)
19846{
19847size_t ret = 0;
19848size_t l HEIMDAL_UNUSED_ATTRIBUTE;
19849int e HEIMDAL_UNUSED_ATTRIBUTE;
19850
19851memset(data, 0, sizeof(*data));
19852{
19853size_t Top_datalen, Top_oldlen;
19854Der_type Top_type;
19855e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
19856if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
19857if(e) goto fail;
19858p += l; len -= l; ret += l;
19859Top_oldlen = len;
19860if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19861len = Top_datalen;
19862{
19863size_t cache_datalen, cache_oldlen;
19864Der_type cache_type;
19865e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cache_type, 0, &cache_datalen, &l);
19866if (e == 0 && cache_type != CONS) { e = ASN1_BAD_ID; }
19867if(e) goto fail;
19868p += l; len -= l; ret += l;
19869cache_oldlen = len;
19870if (cache_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19871len = cache_datalen;
19872{
19873size_t cache_Tag_datalen, cache_Tag_oldlen;
19874Der_type cache_Tag_type;
19875e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cache_Tag_type, UT_OctetString, &cache_Tag_datalen, &l);
19876if (e == 0 && cache_Tag_type != PRIM) { e = ASN1_BAD_ID; }
19877if(e) goto fail;
19878p += l; len -= l; ret += l;
19879cache_Tag_oldlen = len;
19880if (cache_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19881len = cache_Tag_datalen;
19882e = der_get_octet_string(p, len, &(data)->cache, &l);
19883if(e) goto fail;
19884p += l; len -= l; ret += l;
19885if ((&(data)->cache)->length != 16) {
19886e = ASN1_EXACT_CONSTRAINT; goto fail;
19887}
19888len = cache_Tag_oldlen - cache_Tag_datalen;
19889}
19890len = cache_oldlen - cache_datalen;
19891}
19892{
19893size_t addrs_datalen, addrs_oldlen;
19894Der_type addrs_type;
19895e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &addrs_type, 1, &addrs_datalen, &l);
19896if (e == 0 && addrs_type != CONS) { e = ASN1_BAD_ID; }
19897if(e) goto fail;
19898p += l; len -= l; ret += l;
19899addrs_oldlen = len;
19900if (addrs_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19901len = addrs_datalen;
19902e = decode_HostAddresses(p, len, &(data)->addrs, &l);
19903if(e) goto fail;
19904p += l; len -= l; ret += l;
19905len = addrs_oldlen - addrs_datalen;
19906}
19907{
19908size_t flags_datalen, flags_oldlen;
19909Der_type flags_type;
19910e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &flags_type, 2, &flags_datalen, &l);
19911if (e == 0 && flags_type != CONS) { e = ASN1_BAD_ID; }
19912if(e) goto fail;
19913p += l; len -= l; ret += l;
19914flags_oldlen = len;
19915if (flags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19916len = flags_datalen;
19917e = decode_krb5uint32(p, len, &(data)->flags, &l);
19918if(e) goto fail;
19919p += l; len -= l; ret += l;
19920len = flags_oldlen - flags_datalen;
19921}
19922{
19923size_t imp_datalen, imp_oldlen;
19924Der_type imp_type;
19925e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &imp_type, 3, &imp_datalen, &l);
19926if (e == 0 && imp_type != CONS) { e = ASN1_BAD_ID; }
19927if(e) {
19928(data)->imp = NULL;
19929} else {
19930(data)->imp = calloc(1, sizeof(*(data)->imp));
19931if ((data)->imp == NULL) { e = ENOMEM; goto fail; }
19932p += l; len -= l; ret += l;
19933imp_oldlen = len;
19934if (imp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19935len = imp_datalen;
19936e = decode_Principal(p, len, (data)->imp, &l);
19937if(e) goto fail;
19938p += l; len -= l; ret += l;
19939len = imp_oldlen - imp_datalen;
19940}
19941}
19942{
19943size_t ticket_datalen, ticket_oldlen;
19944Der_type ticket_type;
19945e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &ticket_type, 4, &ticket_datalen, &l);
19946if (e == 0 && ticket_type != CONS) { e = ASN1_BAD_ID; }
19947if(e) {
19948(data)->ticket = NULL;
19949} else {
19950(data)->ticket = calloc(1, sizeof(*(data)->ticket));
19951if ((data)->ticket == NULL) { e = ENOMEM; goto fail; }
19952p += l; len -= l; ret += l;
19953ticket_oldlen = len;
19954if (ticket_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19955len = ticket_datalen;
19956{
19957size_t ticket_Tag_datalen, ticket_Tag_oldlen;
19958Der_type ticket_Tag_type;
19959e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ticket_Tag_type, UT_OctetString, &ticket_Tag_datalen, &l);
19960if (e == 0 && ticket_Tag_type != PRIM) { e = ASN1_BAD_ID; }
19961if(e) goto fail;
19962p += l; len -= l; ret += l;
19963ticket_Tag_oldlen = len;
19964if (ticket_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19965len = ticket_Tag_datalen;
19966e = der_get_octet_string(p, len, (data)->ticket, &l);
19967if(e) goto fail;
19968p += l; len -= l; ret += l;
19969len = ticket_Tag_oldlen - ticket_Tag_datalen;
19970}
19971len = ticket_oldlen - ticket_datalen;
19972}
19973}
19974{
19975size_t in_cred_datalen, in_cred_oldlen;
19976Der_type in_cred_type;
19977e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &in_cred_type, 5, &in_cred_datalen, &l);
19978if (e == 0 && in_cred_type != CONS) { e = ASN1_BAD_ID; }
19979if(e) goto fail;
19980p += l; len -= l; ret += l;
19981in_cred_oldlen = len;
19982if (in_cred_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19983len = in_cred_datalen;
19984e = decode_KERB_CRED(p, len, &(data)->in_cred, &l);
19985if(e) goto fail;
19986p += l; len -= l; ret += l;
19987len = in_cred_oldlen - in_cred_datalen;
19988}
19989{
19990size_t krbtgt_datalen, krbtgt_oldlen;
19991Der_type krbtgt_type;
19992e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &krbtgt_type, 6, &krbtgt_datalen, &l);
19993if (e == 0 && krbtgt_type != CONS) { e = ASN1_BAD_ID; }
19994if(e) goto fail;
19995p += l; len -= l; ret += l;
19996krbtgt_oldlen = len;
19997if (krbtgt_datalen > len) { e = ASN1_OVERRUN; goto fail; }
19998len = krbtgt_datalen;
19999e = decode_KERB_CRED(p, len, &(data)->krbtgt, &l);
20000if(e) goto fail;
20001p += l; len -= l; ret += l;
20002len = krbtgt_oldlen - krbtgt_datalen;
20003}
20004{
20005size_t padata_datalen, padata_oldlen;
20006Der_type padata_type;
20007e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &padata_type, 7, &padata_datalen, &l);
20008if (e == 0 && padata_type != CONS) { e = ASN1_BAD_ID; }
20009if(e) goto fail;
20010p += l; len -= l; ret += l;
20011padata_oldlen = len;
20012if (padata_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20013len = padata_datalen;
20014e = decode_METHOD_DATA(p, len, &(data)->padata, &l);
20015if(e) goto fail;
20016p += l; len -= l; ret += l;
20017len = padata_oldlen - padata_datalen;
20018}
20019len = Top_oldlen - Top_datalen;
20020}
20021if(size) *size = ret;
20022return 0;
20023fail:
20024free_KERB_TGS_REQ_IN(data);
20025return e;
20026}
20027
20028void ASN1CALL
20029free_KERB_TGS_REQ_IN(KERB_TGS_REQ_IN *data)
20030{
20031der_free_octet_string(&(data)->cache);
20032free_HostAddresses(&(data)->addrs);
20033free_krb5uint32(&(data)->flags);
20034if((data)->imp) {
20035free_Principal((data)->imp);
20036free((data)->imp);
20037(data)->imp = NULL;
20038}
20039if((data)->ticket) {
20040der_free_octet_string((data)->ticket);
20041free((data)->ticket);
20042(data)->ticket = NULL;
20043}
20044free_KERB_CRED(&(data)->in_cred);
20045free_KERB_CRED(&(data)->krbtgt);
20046free_METHOD_DATA(&(data)->padata);
20047}
20048
20049size_t ASN1CALL
20050length_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *data)
20051{
20052size_t ret = 0;
20053{
20054size_t Top_tag_oldret = ret;
20055ret = 0;
20056ret += der_length_octet_string(&(data)->cache);
20057ret += 1 + der_length_len (ret);
20058ret += 1 + der_length_len (ret);
20059ret += Top_tag_oldret;
20060}
20061{
20062size_t Top_tag_oldret = ret;
20063ret = 0;
20064ret += length_HostAddresses(&(data)->addrs);
20065ret += 1 + der_length_len (ret);
20066ret += Top_tag_oldret;
20067}
20068{
20069size_t Top_tag_oldret = ret;
20070ret = 0;
20071ret += length_krb5uint32(&(data)->flags);
20072ret += 1 + der_length_len (ret);
20073ret += Top_tag_oldret;
20074}
20075if((data)->imp){
20076size_t Top_tag_oldret = ret;
20077ret = 0;
20078ret += length_Principal((data)->imp);
20079ret += 1 + der_length_len (ret);
20080ret += Top_tag_oldret;
20081}
20082if((data)->ticket){
20083size_t Top_tag_oldret = ret;
20084ret = 0;
20085ret += der_length_octet_string((data)->ticket);
20086ret += 1 + der_length_len (ret);
20087ret += 1 + der_length_len (ret);
20088ret += Top_tag_oldret;
20089}
20090{
20091size_t Top_tag_oldret = ret;
20092ret = 0;
20093ret += length_KERB_CRED(&(data)->in_cred);
20094ret += 1 + der_length_len (ret);
20095ret += Top_tag_oldret;
20096}
20097{
20098size_t Top_tag_oldret = ret;
20099ret = 0;
20100ret += length_KERB_CRED(&(data)->krbtgt);
20101ret += 1 + der_length_len (ret);
20102ret += Top_tag_oldret;
20103}
20104{
20105size_t Top_tag_oldret = ret;
20106ret = 0;
20107ret += length_METHOD_DATA(&(data)->padata);
20108ret += 1 + der_length_len (ret);
20109ret += Top_tag_oldret;
20110}
20111ret += 1 + der_length_len (ret);
20112return ret;
20113}
20114
20115int ASN1CALL
20116copy_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *from, KERB_TGS_REQ_IN *to)
20117{
20118memset(to, 0, sizeof(*to));
20119if(der_copy_octet_string(&(from)->cache, &(to)->cache)) goto fail;
20120if(copy_HostAddresses(&(from)->addrs, &(to)->addrs)) goto fail;
20121if(copy_krb5uint32(&(from)->flags, &(to)->flags)) goto fail;
20122if((from)->imp) {
20123(to)->imp = malloc(sizeof(*(to)->imp));
20124if((to)->imp == NULL) goto fail;
20125if(copy_Principal((from)->imp, (to)->imp)) goto fail;
20126}else
20127(to)->imp = NULL;
20128if((from)->ticket) {
20129(to)->ticket = malloc(sizeof(*(to)->ticket));
20130if((to)->ticket == NULL) goto fail;
20131if(der_copy_octet_string((from)->ticket, (to)->ticket)) goto fail;
20132}else
20133(to)->ticket = NULL;
20134if(copy_KERB_CRED(&(from)->in_cred, &(to)->in_cred)) goto fail;
20135if(copy_KERB_CRED(&(from)->krbtgt, &(to)->krbtgt)) goto fail;
20136if(copy_METHOD_DATA(&(from)->padata, &(to)->padata)) goto fail;
20137return 0;
20138fail:
20139free_KERB_TGS_REQ_IN(to);
20140return ENOMEM;
20141}
20142
20143int ASN1CALL
20144encode_KERB_TGS_REQ_OUT(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KERB_TGS_REQ_OUT *data, size_t *size)
20145{
20146size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
20147size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20148int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
20149
20150/* t */
20151{
20152size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20153ret = 0;
20154e = encode_TGS_REQ(p, len, &(data)->t, &l);
20155if (e) return e;
20156p -= l; len -= l; ret += l;
20157
20158e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
20159if (e) return e;
20160p -= l; len -= l; ret += l;
20161
20162ret += Top_tag_oldret;
20163}
20164/* subkey */
20165if((data)->subkey) {
20166size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20167ret = 0;
20168e = encode_EncryptionKey(p, len, (data)->subkey, &l);
20169if (e) return e;
20170p -= l; len -= l; ret += l;
20171
20172e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
20173if (e) return e;
20174p -= l; len -= l; ret += l;
20175
20176ret += Top_tag_oldret;
20177}
20178e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
20179if (e) return e;
20180p -= l; len -= l; ret += l;
20181
20182*size = ret;
20183return 0;
20184}
20185
20186int ASN1CALL
20187decode_KERB_TGS_REQ_OUT(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KERB_TGS_REQ_OUT *data, size_t *size)
20188{
20189size_t ret = 0;
20190size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20191int e HEIMDAL_UNUSED_ATTRIBUTE;
20192
20193memset(data, 0, sizeof(*data));
20194{
20195size_t Top_datalen, Top_oldlen;
20196Der_type Top_type;
20197e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
20198if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
20199if(e) goto fail;
20200p += l; len -= l; ret += l;
20201Top_oldlen = len;
20202if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20203len = Top_datalen;
20204{
20205size_t subkey_datalen, subkey_oldlen;
20206Der_type subkey_type;
20207e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subkey_type, 0, &subkey_datalen, &l);
20208if (e == 0 && subkey_type != CONS) { e = ASN1_BAD_ID; }
20209if(e) {
20210(data)->subkey = NULL;
20211} else {
20212(data)->subkey = calloc(1, sizeof(*(data)->subkey));
20213if ((data)->subkey == NULL) { e = ENOMEM; goto fail; }
20214p += l; len -= l; ret += l;
20215subkey_oldlen = len;
20216if (subkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20217len = subkey_datalen;
20218e = decode_EncryptionKey(p, len, (data)->subkey, &l);
20219if(e) goto fail;
20220p += l; len -= l; ret += l;
20221len = subkey_oldlen - subkey_datalen;
20222}
20223}
20224{
20225size_t t_datalen, t_oldlen;
20226Der_type t_type;
20227e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &t_type, 1, &t_datalen, &l);
20228if (e == 0 && t_type != CONS) { e = ASN1_BAD_ID; }
20229if(e) goto fail;
20230p += l; len -= l; ret += l;
20231t_oldlen = len;
20232if (t_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20233len = t_datalen;
20234e = decode_TGS_REQ(p, len, &(data)->t, &l);
20235if(e) goto fail;
20236p += l; len -= l; ret += l;
20237len = t_oldlen - t_datalen;
20238}
20239len = Top_oldlen - Top_datalen;
20240}
20241if(size) *size = ret;
20242return 0;
20243fail:
20244free_KERB_TGS_REQ_OUT(data);
20245return e;
20246}
20247
20248void ASN1CALL
20249free_KERB_TGS_REQ_OUT(KERB_TGS_REQ_OUT *data)
20250{
20251if((data)->subkey) {
20252free_EncryptionKey((data)->subkey);
20253free((data)->subkey);
20254(data)->subkey = NULL;
20255}
20256free_TGS_REQ(&(data)->t);
20257}
20258
20259size_t ASN1CALL
20260length_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *data)
20261{
20262size_t ret = 0;
20263if((data)->subkey){
20264size_t Top_tag_oldret = ret;
20265ret = 0;
20266ret += length_EncryptionKey((data)->subkey);
20267ret += 1 + der_length_len (ret);
20268ret += Top_tag_oldret;
20269}
20270{
20271size_t Top_tag_oldret = ret;
20272ret = 0;
20273ret += length_TGS_REQ(&(data)->t);
20274ret += 1 + der_length_len (ret);
20275ret += Top_tag_oldret;
20276}
20277ret += 1 + der_length_len (ret);
20278return ret;
20279}
20280
20281int ASN1CALL
20282copy_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *from, KERB_TGS_REQ_OUT *to)
20283{
20284memset(to, 0, sizeof(*to));
20285if((from)->subkey) {
20286(to)->subkey = malloc(sizeof(*(to)->subkey));
20287if((to)->subkey == NULL) goto fail;
20288if(copy_EncryptionKey((from)->subkey, (to)->subkey)) goto fail;
20289}else
20290(to)->subkey = NULL;
20291if(copy_TGS_REQ(&(from)->t, &(to)->t)) goto fail;
20292return 0;
20293fail:
20294free_KERB_TGS_REQ_OUT(to);
20295return ENOMEM;
20296}
20297
20298int ASN1CALL
20299encode_KERB_TGS_REP_IN(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KERB_TGS_REP_IN *data, size_t *size)
20300{
20301size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
20302size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20303int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
20304
20305/* t */
20306{
20307size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20308ret = 0;
20309e = encode_TGS_REP(p, len, &(data)->t, &l);
20310if (e) return e;
20311p -= l; len -= l; ret += l;
20312
20313e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
20314if (e) return e;
20315p -= l; len -= l; ret += l;
20316
20317ret += Top_tag_oldret;
20318}
20319/* in_cred */
20320{
20321size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20322ret = 0;
20323e = encode_KERB_CRED(p, len, &(data)->in_cred, &l);
20324if (e) return e;
20325p -= l; len -= l; ret += l;
20326
20327e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
20328if (e) return e;
20329p -= l; len -= l; ret += l;
20330
20331ret += Top_tag_oldret;
20332}
20333/* subkey */
20334if((data)->subkey) {
20335size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20336ret = 0;
20337e = encode_EncryptionKey(p, len, (data)->subkey, &l);
20338if (e) return e;
20339p -= l; len -= l; ret += l;
20340
20341e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
20342if (e) return e;
20343p -= l; len -= l; ret += l;
20344
20345ret += Top_tag_oldret;
20346}
20347/* cache */
20348{
20349size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20350ret = 0;
20351e = der_put_octet_string(p, len, &(data)->cache, &l);
20352if (e) return e;
20353p -= l; len -= l; ret += l;
20354
20355e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
20356if (e) return e;
20357p -= l; len -= l; ret += l;
20358
20359e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
20360if (e) return e;
20361p -= l; len -= l; ret += l;
20362
20363ret += Top_tag_oldret;
20364}
20365e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
20366if (e) return e;
20367p -= l; len -= l; ret += l;
20368
20369*size = ret;
20370return 0;
20371}
20372
20373int ASN1CALL
20374decode_KERB_TGS_REP_IN(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KERB_TGS_REP_IN *data, size_t *size)
20375{
20376size_t ret = 0;
20377size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20378int e HEIMDAL_UNUSED_ATTRIBUTE;
20379
20380memset(data, 0, sizeof(*data));
20381{
20382size_t Top_datalen, Top_oldlen;
20383Der_type Top_type;
20384e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
20385if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
20386if(e) goto fail;
20387p += l; len -= l; ret += l;
20388Top_oldlen = len;
20389if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20390len = Top_datalen;
20391{
20392size_t cache_datalen, cache_oldlen;
20393Der_type cache_type;
20394e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cache_type, 0, &cache_datalen, &l);
20395if (e == 0 && cache_type != CONS) { e = ASN1_BAD_ID; }
20396if(e) goto fail;
20397p += l; len -= l; ret += l;
20398cache_oldlen = len;
20399if (cache_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20400len = cache_datalen;
20401{
20402size_t cache_Tag_datalen, cache_Tag_oldlen;
20403Der_type cache_Tag_type;
20404e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cache_Tag_type, UT_OctetString, &cache_Tag_datalen, &l);
20405if (e == 0 && cache_Tag_type != PRIM) { e = ASN1_BAD_ID; }
20406if(e) goto fail;
20407p += l; len -= l; ret += l;
20408cache_Tag_oldlen = len;
20409if (cache_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20410len = cache_Tag_datalen;
20411e = der_get_octet_string(p, len, &(data)->cache, &l);
20412if(e) goto fail;
20413p += l; len -= l; ret += l;
20414if ((&(data)->cache)->length != 16) {
20415e = ASN1_EXACT_CONSTRAINT; goto fail;
20416}
20417len = cache_Tag_oldlen - cache_Tag_datalen;
20418}
20419len = cache_oldlen - cache_datalen;
20420}
20421{
20422size_t subkey_datalen, subkey_oldlen;
20423Der_type subkey_type;
20424e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subkey_type, 1, &subkey_datalen, &l);
20425if (e == 0 && subkey_type != CONS) { e = ASN1_BAD_ID; }
20426if(e) {
20427(data)->subkey = NULL;
20428} else {
20429(data)->subkey = calloc(1, sizeof(*(data)->subkey));
20430if ((data)->subkey == NULL) { e = ENOMEM; goto fail; }
20431p += l; len -= l; ret += l;
20432subkey_oldlen = len;
20433if (subkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20434len = subkey_datalen;
20435e = decode_EncryptionKey(p, len, (data)->subkey, &l);
20436if(e) goto fail;
20437p += l; len -= l; ret += l;
20438len = subkey_oldlen - subkey_datalen;
20439}
20440}
20441{
20442size_t in_cred_datalen, in_cred_oldlen;
20443Der_type in_cred_type;
20444e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &in_cred_type, 2, &in_cred_datalen, &l);
20445if (e == 0 && in_cred_type != CONS) { e = ASN1_BAD_ID; }
20446if(e) goto fail;
20447p += l; len -= l; ret += l;
20448in_cred_oldlen = len;
20449if (in_cred_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20450len = in_cred_datalen;
20451e = decode_KERB_CRED(p, len, &(data)->in_cred, &l);
20452if(e) goto fail;
20453p += l; len -= l; ret += l;
20454len = in_cred_oldlen - in_cred_datalen;
20455}
20456{
20457size_t t_datalen, t_oldlen;
20458Der_type t_type;
20459e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &t_type, 3, &t_datalen, &l);
20460if (e == 0 && t_type != CONS) { e = ASN1_BAD_ID; }
20461if(e) goto fail;
20462p += l; len -= l; ret += l;
20463t_oldlen = len;
20464if (t_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20465len = t_datalen;
20466e = decode_TGS_REP(p, len, &(data)->t, &l);
20467if(e) goto fail;
20468p += l; len -= l; ret += l;
20469len = t_oldlen - t_datalen;
20470}
20471len = Top_oldlen - Top_datalen;
20472}
20473if(size) *size = ret;
20474return 0;
20475fail:
20476free_KERB_TGS_REP_IN(data);
20477return e;
20478}
20479
20480void ASN1CALL
20481free_KERB_TGS_REP_IN(KERB_TGS_REP_IN *data)
20482{
20483der_free_octet_string(&(data)->cache);
20484if((data)->subkey) {
20485free_EncryptionKey((data)->subkey);
20486free((data)->subkey);
20487(data)->subkey = NULL;
20488}
20489free_KERB_CRED(&(data)->in_cred);
20490free_TGS_REP(&(data)->t);
20491}
20492
20493size_t ASN1CALL
20494length_KERB_TGS_REP_IN(const KERB_TGS_REP_IN *data)
20495{
20496size_t ret = 0;
20497{
20498size_t Top_tag_oldret = ret;
20499ret = 0;
20500ret += der_length_octet_string(&(data)->cache);
20501ret += 1 + der_length_len (ret);
20502ret += 1 + der_length_len (ret);
20503ret += Top_tag_oldret;
20504}
20505if((data)->subkey){
20506size_t Top_tag_oldret = ret;
20507ret = 0;
20508ret += length_EncryptionKey((data)->subkey);
20509ret += 1 + der_length_len (ret);
20510ret += Top_tag_oldret;
20511}
20512{
20513size_t Top_tag_oldret = ret;
20514ret = 0;
20515ret += length_KERB_CRED(&(data)->in_cred);
20516ret += 1 + der_length_len (ret);
20517ret += Top_tag_oldret;
20518}
20519{
20520size_t Top_tag_oldret = ret;
20521ret = 0;
20522ret += length_TGS_REP(&(data)->t);
20523ret += 1 + der_length_len (ret);
20524ret += Top_tag_oldret;
20525}
20526ret += 1 + der_length_len (ret);
20527return ret;
20528}
20529
20530int ASN1CALL
20531copy_KERB_TGS_REP_IN(const KERB_TGS_REP_IN *from, KERB_TGS_REP_IN *to)
20532{
20533memset(to, 0, sizeof(*to));
20534if(der_copy_octet_string(&(from)->cache, &(to)->cache)) goto fail;
20535if((from)->subkey) {
20536(to)->subkey = malloc(sizeof(*(to)->subkey));
20537if((to)->subkey == NULL) goto fail;
20538if(copy_EncryptionKey((from)->subkey, (to)->subkey)) goto fail;
20539}else
20540(to)->subkey = NULL;
20541if(copy_KERB_CRED(&(from)->in_cred, &(to)->in_cred)) goto fail;
20542if(copy_TGS_REP(&(from)->t, &(to)->t)) goto fail;
20543return 0;
20544fail:
20545free_KERB_TGS_REP_IN(to);
20546return ENOMEM;
20547}
20548
20549int ASN1CALL
20550encode_KERB_TGS_REP_OUT(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KERB_TGS_REP_OUT *data, size_t *size)
20551{
20552size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
20553size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20554int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
20555
20556/* subkey */
20557{
20558size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20559ret = 0;
20560e = encode_EncryptionKey(p, len, &(data)->subkey, &l);
20561if (e) return e;
20562p -= l; len -= l; ret += l;
20563
20564e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
20565if (e) return e;
20566p -= l; len -= l; ret += l;
20567
20568ret += Top_tag_oldret;
20569}
20570/* cred */
20571{
20572size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20573ret = 0;
20574e = encode_KERB_CRED(p, len, &(data)->cred, &l);
20575if (e) return e;
20576p -= l; len -= l; ret += l;
20577
20578e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
20579if (e) return e;
20580p -= l; len -= l; ret += l;
20581
20582ret += Top_tag_oldret;
20583}
20584/* cache */
20585{
20586size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20587ret = 0;
20588e = der_put_octet_string(p, len, &(data)->cache, &l);
20589if (e) return e;
20590p -= l; len -= l; ret += l;
20591
20592e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
20593if (e) return e;
20594p -= l; len -= l; ret += l;
20595
20596e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
20597if (e) return e;
20598p -= l; len -= l; ret += l;
20599
20600ret += Top_tag_oldret;
20601}
20602e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
20603if (e) return e;
20604p -= l; len -= l; ret += l;
20605
20606*size = ret;
20607return 0;
20608}
20609
20610int ASN1CALL
20611decode_KERB_TGS_REP_OUT(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KERB_TGS_REP_OUT *data, size_t *size)
20612{
20613size_t ret = 0;
20614size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20615int e HEIMDAL_UNUSED_ATTRIBUTE;
20616
20617memset(data, 0, sizeof(*data));
20618{
20619size_t Top_datalen, Top_oldlen;
20620Der_type Top_type;
20621e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
20622if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
20623if(e) goto fail;
20624p += l; len -= l; ret += l;
20625Top_oldlen = len;
20626if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20627len = Top_datalen;
20628{
20629size_t cache_datalen, cache_oldlen;
20630Der_type cache_type;
20631e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cache_type, 0, &cache_datalen, &l);
20632if (e == 0 && cache_type != CONS) { e = ASN1_BAD_ID; }
20633if(e) goto fail;
20634p += l; len -= l; ret += l;
20635cache_oldlen = len;
20636if (cache_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20637len = cache_datalen;
20638{
20639size_t cache_Tag_datalen, cache_Tag_oldlen;
20640Der_type cache_Tag_type;
20641e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cache_Tag_type, UT_OctetString, &cache_Tag_datalen, &l);
20642if (e == 0 && cache_Tag_type != PRIM) { e = ASN1_BAD_ID; }
20643if(e) goto fail;
20644p += l; len -= l; ret += l;
20645cache_Tag_oldlen = len;
20646if (cache_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20647len = cache_Tag_datalen;
20648e = der_get_octet_string(p, len, &(data)->cache, &l);
20649if(e) goto fail;
20650p += l; len -= l; ret += l;
20651if ((&(data)->cache)->length != 16) {
20652e = ASN1_EXACT_CONSTRAINT; goto fail;
20653}
20654len = cache_Tag_oldlen - cache_Tag_datalen;
20655}
20656len = cache_oldlen - cache_datalen;
20657}
20658{
20659size_t cred_datalen, cred_oldlen;
20660Der_type cred_type;
20661e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cred_type, 1, &cred_datalen, &l);
20662if (e == 0 && cred_type != CONS) { e = ASN1_BAD_ID; }
20663if(e) goto fail;
20664p += l; len -= l; ret += l;
20665cred_oldlen = len;
20666if (cred_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20667len = cred_datalen;
20668e = decode_KERB_CRED(p, len, &(data)->cred, &l);
20669if(e) goto fail;
20670p += l; len -= l; ret += l;
20671len = cred_oldlen - cred_datalen;
20672}
20673{
20674size_t subkey_datalen, subkey_oldlen;
20675Der_type subkey_type;
20676e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subkey_type, 2, &subkey_datalen, &l);
20677if (e == 0 && subkey_type != CONS) { e = ASN1_BAD_ID; }
20678if(e) goto fail;
20679p += l; len -= l; ret += l;
20680subkey_oldlen = len;
20681if (subkey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20682len = subkey_datalen;
20683e = decode_EncryptionKey(p, len, &(data)->subkey, &l);
20684if(e) goto fail;
20685p += l; len -= l; ret += l;
20686len = subkey_oldlen - subkey_datalen;
20687}
20688len = Top_oldlen - Top_datalen;
20689}
20690if(size) *size = ret;
20691return 0;
20692fail:
20693free_KERB_TGS_REP_OUT(data);
20694return e;
20695}
20696
20697void ASN1CALL
20698free_KERB_TGS_REP_OUT(KERB_TGS_REP_OUT *data)
20699{
20700der_free_octet_string(&(data)->cache);
20701free_KERB_CRED(&(data)->cred);
20702free_EncryptionKey(&(data)->subkey);
20703}
20704
20705size_t ASN1CALL
20706length_KERB_TGS_REP_OUT(const KERB_TGS_REP_OUT *data)
20707{
20708size_t ret = 0;
20709{
20710size_t Top_tag_oldret = ret;
20711ret = 0;
20712ret += der_length_octet_string(&(data)->cache);
20713ret += 1 + der_length_len (ret);
20714ret += 1 + der_length_len (ret);
20715ret += Top_tag_oldret;
20716}
20717{
20718size_t Top_tag_oldret = ret;
20719ret = 0;
20720ret += length_KERB_CRED(&(data)->cred);
20721ret += 1 + der_length_len (ret);
20722ret += Top_tag_oldret;
20723}
20724{
20725size_t Top_tag_oldret = ret;
20726ret = 0;
20727ret += length_EncryptionKey(&(data)->subkey);
20728ret += 1 + der_length_len (ret);
20729ret += Top_tag_oldret;
20730}
20731ret += 1 + der_length_len (ret);
20732return ret;
20733}
20734
20735int ASN1CALL
20736copy_KERB_TGS_REP_OUT(const KERB_TGS_REP_OUT *from, KERB_TGS_REP_OUT *to)
20737{
20738memset(to, 0, sizeof(*to));
20739if(der_copy_octet_string(&(from)->cache, &(to)->cache)) goto fail;
20740if(copy_KERB_CRED(&(from)->cred, &(to)->cred)) goto fail;
20741if(copy_EncryptionKey(&(from)->subkey, &(to)->subkey)) goto fail;
20742return 0;
20743fail:
20744free_KERB_TGS_REP_OUT(to);
20745return ENOMEM;
20746}
20747
20748int ASN1CALL
20749encode_KERB_ARMOR_SERVICE_REPLY(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KERB_ARMOR_SERVICE_REPLY *data, size_t *size)
20750{
20751size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
20752size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20753int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
20754
20755/* armor-key */
20756{
20757size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20758ret = 0;
20759e = encode_EncryptionKey(p, len, &(data)->armor_key, &l);
20760if (e) return e;
20761p -= l; len -= l; ret += l;
20762
20763e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
20764if (e) return e;
20765p -= l; len -= l; ret += l;
20766
20767ret += Top_tag_oldret;
20768}
20769/* armor */
20770{
20771size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
20772ret = 0;
20773e = encode_KrbFastArmor(p, len, &(data)->armor, &l);
20774if (e) return e;
20775p -= l; len -= l; ret += l;
20776
20777e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
20778if (e) return e;
20779p -= l; len -= l; ret += l;
20780
20781ret += Top_tag_oldret;
20782}
20783e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
20784if (e) return e;
20785p -= l; len -= l; ret += l;
20786
20787*size = ret;
20788return 0;
20789}
20790
20791int ASN1CALL
20792decode_KERB_ARMOR_SERVICE_REPLY(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KERB_ARMOR_SERVICE_REPLY *data, size_t *size)
20793{
20794size_t ret = 0;
20795size_t l HEIMDAL_UNUSED_ATTRIBUTE;
20796int e HEIMDAL_UNUSED_ATTRIBUTE;
20797
20798memset(data, 0, sizeof(*data));
20799{
20800size_t Top_datalen, Top_oldlen;
20801Der_type Top_type;
20802e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
20803if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
20804if(e) goto fail;
20805p += l; len -= l; ret += l;
20806Top_oldlen = len;
20807if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20808len = Top_datalen;
20809{
20810size_t armor_datalen, armor_oldlen;
20811Der_type armor_type;
20812e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_type, 0, &armor_datalen, &l);
20813if (e == 0 && armor_type != CONS) { e = ASN1_BAD_ID; }
20814if(e) goto fail;
20815p += l; len -= l; ret += l;
20816armor_oldlen = len;
20817if (armor_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20818len = armor_datalen;
20819e = decode_KrbFastArmor(p, len, &(data)->armor, &l);
20820if(e) goto fail;
20821p += l; len -= l; ret += l;
20822len = armor_oldlen - armor_datalen;
20823}
20824{
20825size_t armor_key_datalen, armor_key_oldlen;
20826Der_type armor_key_type;
20827e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &armor_key_type, 1, &armor_key_datalen, &l);
20828if (e == 0 && armor_key_type != CONS) { e = ASN1_BAD_ID; }
20829if(e) goto fail;
20830p += l; len -= l; ret += l;
20831armor_key_oldlen = len;
20832if (armor_key_datalen > len) { e = ASN1_OVERRUN; goto fail; }
20833len = armor_key_datalen;
20834e = decode_EncryptionKey(p, len, &(data)->armor_key, &l);
20835if(e) goto fail;
20836p += l; len -= l; ret += l;
20837len = armor_key_oldlen - armor_key_datalen;
20838}
20839len = Top_oldlen - Top_datalen;
20840}
20841if(size) *size = ret;
20842return 0;
20843fail:
20844free_KERB_ARMOR_SERVICE_REPLY(data);
20845return e;
20846}
20847
20848void ASN1CALL
20849free_KERB_ARMOR_SERVICE_REPLY(KERB_ARMOR_SERVICE_REPLY *data)
20850{
20851free_KrbFastArmor(&(data)->armor);
20852free_EncryptionKey(&(data)->armor_key);
20853}
20854
20855size_t ASN1CALL
20856length_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *data)
20857{
20858size_t ret = 0;
20859{
20860size_t Top_tag_oldret = ret;
20861ret = 0;
20862ret += length_KrbFastArmor(&(data)->armor);
20863ret += 1 + der_length_len (ret);
20864ret += Top_tag_oldret;
20865}
20866{
20867size_t Top_tag_oldret = ret;
20868ret = 0;
20869ret += length_EncryptionKey(&(data)->armor_key);
20870ret += 1 + der_length_len (ret);
20871ret += Top_tag_oldret;
20872}
20873ret += 1 + der_length_len (ret);
20874return ret;
20875}
20876
20877int ASN1CALL
20878copy_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *from, KERB_ARMOR_SERVICE_REPLY *to)
20879{
20880memset(to, 0, sizeof(*to));
20881if(copy_KrbFastArmor(&(from)->armor, &(to)->armor)) goto fail;
20882if(copy_EncryptionKey(&(from)->armor_key, &(to)->armor_key)) goto fail;
20883return 0;
20884fail:
20885free_KERB_ARMOR_SERVICE_REPLY(to);
20886return ENOMEM;
20887}
20888
20889